# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.323440745472908*${_u_distance}
variable latticeconst_converted equal 3.323440745472908*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.32344074547291
Lattice spacing in x,y,z = 3.3234407 3.3234407 3.3234407
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (33.234407 33.234407 33.234407)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (33.234407 33.234407 33.234407)
  create_atoms CPU = 0.000 seconds

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

kim_interactions Ta

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

kim interactions Ta
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_ParkFellingerLenosky_2012_Ta__MO_105449194206_002
pair_coeff * * Ta
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 180.9479

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_105449194206_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -16071.173     -16071.173     -16146.92      -16146.92       293.15         293.15         36708.262      36708.262      2204.0492      2204.0492    
      1000  -15991.983     -15991.983     -16068.301     -16068.301      295.36113      295.36113      36823.212      36823.212      1257.7108      1257.7108    
Loop time of 46.4582 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.860 ns/day, 12.905 hours/ns, 21.525 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    | 46.368     | 46.368     | 46.368     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.017346   | 0.017346   | 0.017346   |   0.0 |  0.04
Output  | 0.00058541 | 0.00058541 | 0.00058541 |   0.0 |  0.00
Modify  | 0.063069   | 0.063069   | 0.063069   |   0.0 |  0.14
Other   |            | 0.009327   |            |       |  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:       224000 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -15991.983     -15991.983     -16068.301     -16068.301      295.36113      295.36113      36823.212      36823.212      1257.7108      1257.7108    
      2000  -15992.867     -15992.867     -16069.462     -16069.462      296.42913      296.42913      36868.189      36868.189     -1312.2406     -1312.2406    
Loop time of 46.6088 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.854 ns/day, 12.947 hours/ns, 21.455 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    | 46.513     | 46.513     | 46.513     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.018687   | 0.018687   | 0.018687   |   0.0 |  0.04
Output  | 6.2517e-05 | 6.2517e-05 | 6.2517e-05 |   0.0 |  0.00
Modify  | 0.064113   | 0.064113   | 0.064113   |   0.0 |  0.14
Other   |            | 0.01262    |            |       |  0.03

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

Total # of neighbors = 212828
Ave neighs/atom = 106.414
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -15992.867     -15992.867     -16069.462     -16069.462      296.42913      296.42913      36868.189      36868.189     -1312.2406     -1312.2406    
      3000  -15994.004     -15994.004     -16071.142     -16071.142      298.53082      298.53082      36847.282      36847.282     -467.844       -467.844      
Loop time of 46.6228 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.853 ns/day, 12.951 hours/ns, 21.449 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    | 46.525     | 46.525     | 46.525     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019481   | 0.019481   | 0.019481   |   0.0 |  0.04
Output  | 5.6827e-05 | 5.6827e-05 | 5.6827e-05 |   0.0 |  0.00
Modify  | 0.064829   | 0.064829   | 0.064829   |   0.0 |  0.14
Other   |            | 0.01378    |            |       |  0.03

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

Total # of neighbors = 212310
Ave neighs/atom = 106.155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -15994.004     -15994.004     -16071.142     -16071.142      298.53082      298.53082      36847.282      36847.282     -467.844       -467.844      
      4000  -15996.658     -15996.658     -16073.527     -16073.527      297.49279      297.49279      36796.527      36796.527      1760.5407      1760.5407    
Loop time of 46.6122 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.854 ns/day, 12.948 hours/ns, 21.454 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    | 46.515     | 46.515     | 46.515     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019315   | 0.019315   | 0.019315   |   0.0 |  0.04
Output  | 5.8901e-05 | 5.8901e-05 | 5.8901e-05 |   0.0 |  0.00
Modify  | 0.064517   | 0.064517   | 0.064517   |   0.0 |  0.14
Other   |            | 0.01346    |            |       |  0.03

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

Total # of neighbors = 212348
Ave neighs/atom = 106.174
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -15996.658     -15996.658     -16073.527     -16073.527      297.49279      297.49279      36796.527      36796.527      1760.5407      1760.5407    
      5000  -15992.311     -15992.311     -16074.262     -16074.262      317.15854      317.15854      36790.308      36790.308      2436.5783      2436.5783    
Loop time of 46.6309 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.853 ns/day, 12.953 hours/ns, 21.445 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    | 46.532     | 46.532     | 46.532     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019567   | 0.019567   | 0.019567   |   0.0 |  0.04
Output  | 4.7289e-05 | 4.7289e-05 | 4.7289e-05 |   0.0 |  0.00
Modify  | 0.065378   | 0.065378   | 0.065378   |   0.0 |  0.14
Other   |            | 0.01401    |            |       |  0.03

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

Total # of neighbors = 212876
Ave neighs/atom = 106.438
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 = 289.614803848467, Press = -351.334670077046
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -15992.311     -15992.311     -16074.262     -16074.262      317.15854      317.15854      36790.308      36790.308      2436.5783      2436.5783    
      6000  -15994.331     -15994.331     -16076.208     -16076.208      316.87249      316.87249      36849.53       36849.53      -1030.3934     -1030.3934    
Loop time of 46.5986 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.854 ns/day, 12.944 hours/ns, 21.460 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    | 46.495     | 46.495     | 46.495     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.020106   | 0.020106   | 0.020106   |   0.0 |  0.04
Output  | 2.68e-05   | 2.68e-05   | 2.68e-05   |   0.0 |  0.00
Modify  | 0.068412   | 0.068412   | 0.068412   |   0.0 |  0.15
Other   |            | 0.01472    |            |       |  0.03

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

Total # of neighbors = 213412
Ave neighs/atom = 106.706
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.629629006704, Press = -43.1548406049711
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -15994.331     -15994.331     -16076.208     -16076.208      316.87249      316.87249      36849.53       36849.53      -1030.3934     -1030.3934    
      7000  -15997.484     -15997.484     -16068.035     -16068.035      273.03851      273.03851      36865.585      36865.585     -1206.8065     -1206.8065    
Loop time of 46.577 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.855 ns/day, 12.938 hours/ns, 21.470 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.475     | 46.475     | 46.475     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019777   | 0.019777   | 0.019777   |   0.0 |  0.04
Output  | 4.4293e-05 | 4.4293e-05 | 4.4293e-05 |   0.0 |  0.00
Modify  | 0.067945   | 0.067945   | 0.067945   |   0.0 |  0.15
Other   |            | 0.01429    |            |       |  0.03

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

Total # of neighbors = 212782
Ave neighs/atom = 106.391
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.187531887279, Press = -11.0287588307847
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -15997.484     -15997.484     -16068.035     -16068.035      273.03851      273.03851      36865.585      36865.585     -1206.8065     -1206.8065    
      8000  -15993.326     -15993.326     -16073.458     -16073.458      310.12046      310.12046      36868.353      36868.353     -1736.2511     -1736.2511    
Loop time of 46.504 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.858 ns/day, 12.918 hours/ns, 21.504 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    | 46.404     | 46.404     | 46.404     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019224   | 0.019224   | 0.019224   |   0.0 |  0.04
Output  | 3.9785e-05 | 3.9785e-05 | 3.9785e-05 |   0.0 |  0.00
Modify  | 0.067081   | 0.067081   | 0.067081   |   0.0 |  0.14
Other   |            | 0.01336    |            |       |  0.03

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

Total # of neighbors = 211800
Ave neighs/atom = 105.9
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.018199896265, Press = -30.6035117907874
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -15993.326     -15993.326     -16073.458     -16073.458      310.12046      310.12046      36868.353      36868.353     -1736.2511     -1736.2511    
      9000  -15994.936     -15994.936     -16070.717     -16070.717      293.28103      293.28103      36811.01       36811.01       1377.8767      1377.8767    
Loop time of 46.6028 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.854 ns/day, 12.945 hours/ns, 21.458 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    | 46.501     | 46.501     | 46.501     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0198     | 0.0198     | 0.0198     |   0.0 |  0.04
Output  | 4.4494e-05 | 4.4494e-05 | 4.4494e-05 |   0.0 |  0.00
Modify  | 0.067902   | 0.067902   | 0.067902   |   0.0 |  0.15
Other   |            | 0.01425    |            |       |  0.03

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

Total # of neighbors = 212384
Ave neighs/atom = 106.192
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.23352810268, Press = -14.7089686023218
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -15994.936     -15994.936     -16070.717     -16070.717      293.28103      293.28103      36811.01       36811.01       1377.8767      1377.8767    
     10000  -15992.539     -15992.539     -16072.85      -16072.85       310.81106      310.81106      36869.332      36869.332     -1758.0782     -1758.0782    
Loop time of 46.5382 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.857 ns/day, 12.927 hours/ns, 21.488 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.439     | 46.439     | 46.439     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019016   | 0.019016   | 0.019016   |   0.0 |  0.04
Output  | 4.2139e-05 | 4.2139e-05 | 4.2139e-05 |   0.0 |  0.00
Modify  | 0.06674    | 0.06674    | 0.06674    |   0.0 |  0.14
Other   |            | 0.01292    |            |       |  0.03

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

Total # of neighbors = 212930
Ave neighs/atom = 106.465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.614722231007, Press = -12.9572051266843
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -15992.539     -15992.539     -16072.85      -16072.85       310.81106      310.81106      36869.332      36869.332     -1758.0782     -1758.0782    
     11000  -15991.879     -15991.879     -16066.326     -16066.326      288.117        288.117        36863.853      36863.853     -1008.6469     -1008.6469    
Loop time of 46.5233 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.857 ns/day, 12.923 hours/ns, 21.495 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.421     | 46.421     | 46.421     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01996    | 0.01996    | 0.01996    |   0.0 |  0.04
Output  | 2.7412e-05 | 2.7412e-05 | 2.7412e-05 |   0.0 |  0.00
Modify  | 0.068059   | 0.068059   | 0.068059   |   0.0 |  0.15
Other   |            | 0.01454    |            |       |  0.03

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

Total # of neighbors = 212518
Ave neighs/atom = 106.259
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.964286951329, Press = -11.2335491985956
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -15991.879     -15991.879     -16066.326     -16066.326      288.117        288.117        36863.853      36863.853     -1008.6469     -1008.6469    
     12000  -15991.952     -15991.952     -16070.219     -16070.219      302.90093      302.90093      36841.986      36841.986      54.096553      54.096553    
Loop time of 46.5049 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.858 ns/day, 12.918 hours/ns, 21.503 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    | 46.405     | 46.405     | 46.405     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01937    | 0.01937    | 0.01937    |   0.0 |  0.04
Output  | 3.9464e-05 | 3.9464e-05 | 3.9464e-05 |   0.0 |  0.00
Modify  | 0.067137   | 0.067137   | 0.067137   |   0.0 |  0.14
Other   |            | 0.01347    |            |       |  0.03

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

Total # of neighbors = 212262
Ave neighs/atom = 106.131
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.720460407151, Press = -10.3609142412634
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -15991.952     -15991.952     -16070.219     -16070.219      302.90093      302.90093      36841.986      36841.986      54.096553      54.096553    
     13000  -15996.363     -15996.363     -16073.257     -16073.257      297.58486      297.58486      36868.356      36868.356     -1837.7011     -1837.7011    
Loop time of 46.5005 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.858 ns/day, 12.917 hours/ns, 21.505 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.402     | 46.402     | 46.402     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.018973   | 0.018973   | 0.018973   |   0.0 |  0.04
Output  | 4.3712e-05 | 4.3712e-05 | 4.3712e-05 |   0.0 |  0.00
Modify  | 0.066886   | 0.066886   | 0.066886   |   0.0 |  0.14
Other   |            | 0.01297    |            |       |  0.03

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

Total # of neighbors = 212362
Ave neighs/atom = 106.181
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.65413443986, Press = -9.86146138860767
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -15996.363     -15996.363     -16073.257     -16073.257      297.58486      297.58486      36868.356      36868.356     -1837.7011     -1837.7011    
     14000  -15994.437     -15994.437     -16067.962     -16067.962      284.5478       284.5478       36891.162      36891.162     -2333.8095     -2333.8095    
Loop time of 46.549 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.856 ns/day, 12.930 hours/ns, 21.483 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.448     | 46.448     | 46.448     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019579   | 0.019579   | 0.019579   |   0.0 |  0.04
Output  | 4.6488e-05 | 4.6488e-05 | 4.6488e-05 |   0.0 |  0.00
Modify  | 0.067567   | 0.067567   | 0.067567   |   0.0 |  0.15
Other   |            | 0.01394    |            |       |  0.03

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

Total # of neighbors = 212368
Ave neighs/atom = 106.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 = 292.679613381548, Press = -4.12070225688464
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -15994.437     -15994.437     -16067.962     -16067.962      284.5478       284.5478       36891.162      36891.162     -2333.8095     -2333.8095    
     15000  -15990.503     -15990.503     -16071.597     -16071.597      313.84183      313.84183      36906.676      36906.676     -3421.8384     -3421.8384    
Loop time of 46.4858 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.859 ns/day, 12.913 hours/ns, 21.512 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.383     | 46.383     | 46.383     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.020077   | 0.020077   | 0.020077   |   0.0 |  0.04
Output  | 2.7331e-05 | 2.7331e-05 | 2.7331e-05 |   0.0 |  0.00
Modify  | 0.068047   | 0.068047   | 0.068047   |   0.0 |  0.15
Other   |            | 0.01436    |            |       |  0.03

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

Total # of neighbors = 211840
Ave neighs/atom = 105.92
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.809762042117, Press = -10.4614758421089
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -15990.503     -15990.503     -16071.597     -16071.597      313.84183      313.84183      36906.676      36906.676     -3421.8384     -3421.8384    
     16000  -15994.994     -15994.994     -16071.549     -16071.549      296.27701      296.27701      36860.625      36860.625     -1229.5737     -1229.5737    
Loop time of 46.529 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.857 ns/day, 12.925 hours/ns, 21.492 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.429     | 46.429     | 46.429     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019405   | 0.019405   | 0.019405   |   0.0 |  0.04
Output  | 4.6047e-05 | 4.6047e-05 | 4.6047e-05 |   0.0 |  0.00
Modify  | 0.06732    | 0.06732    | 0.06732    |   0.0 |  0.14
Other   |            | 0.01361    |            |       |  0.03

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

Total # of neighbors = 211718
Ave neighs/atom = 105.859
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.114374838321, Press = -7.94385921804575
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -15994.994     -15994.994     -16071.549     -16071.549      296.27701      296.27701      36860.625      36860.625     -1229.5737     -1229.5737    
     17000  -15994.768     -15994.768     -16066.977     -16066.977      279.45601      279.45601      36863.255      36863.255     -1038.7502     -1038.7502    
Loop time of 46.5671 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.855 ns/day, 12.935 hours/ns, 21.474 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.466     | 46.466     | 46.466     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019511   | 0.019511   | 0.019511   |   0.0 |  0.04
Output  | 3.9544e-05 | 3.9544e-05 | 3.9544e-05 |   0.0 |  0.00
Modify  | 0.067518   | 0.067518   | 0.067518   |   0.0 |  0.14
Other   |            | 0.01379    |            |       |  0.03

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

Total # of neighbors = 212210
Ave neighs/atom = 106.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 = 293.069832902939, Press = -6.22982897229392
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -15994.768     -15994.768     -16066.977     -16066.977      279.45601      279.45601      36863.255      36863.255     -1038.7502     -1038.7502    
     18000  -15994.189     -15994.189     -16075.077     -16075.077      313.04439      313.04439      36869.058      36869.058     -1901.3928     -1901.3928    
Loop time of 46.6244 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.853 ns/day, 12.951 hours/ns, 21.448 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.537     | 46.537     | 46.537     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01609    | 0.01609    | 0.01609    |   0.0 |  0.03
Output  | 5.0004e-05 | 5.0004e-05 | 5.0004e-05 |   0.0 |  0.00
Modify  | 0.063548   | 0.063548   | 0.063548   |   0.0 |  0.14
Other   |            | 0.007549   |            |       |  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:       211986 ave      211986 max      211986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211986
Ave neighs/atom = 105.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.910483342582, Press = -5.92776356939432
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -15994.189     -15994.189     -16075.077     -16075.077      313.04439      313.04439      36869.058      36869.058     -1901.3928     -1901.3928    
     19000  -15995.138     -15995.138     -16073.235     -16073.235      302.24213      302.24213      36825.887      36825.887      416.63745      416.63745    
Loop time of 46.7185 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.849 ns/day, 12.977 hours/ns, 21.405 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    | 46.635     | 46.635     | 46.635     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015046   | 0.015046   | 0.015046   |   0.0 |  0.03
Output  | 7.2826e-05 | 7.2826e-05 | 7.2826e-05 |   0.0 |  0.00
Modify  | 0.062171   | 0.062171   | 0.062171   |   0.0 |  0.13
Other   |            | 0.005678   |            |       |  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:       212434 ave      212434 max      212434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212434
Ave neighs/atom = 106.217
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.996670642549, Press = -8.1157632463578
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -15995.138     -15995.138     -16073.235     -16073.235      302.24213      302.24213      36825.887      36825.887      416.63745      416.63745    
     20000  -15993.695     -15993.695     -16072.378     -16072.378      304.51076      304.51076      36802.568      36802.568      1921.6019      1921.6019    
Loop time of 46.837 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.845 ns/day, 13.010 hours/ns, 21.351 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    | 46.754     | 46.754     | 46.754     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015191   | 0.015191   | 0.015191   |   0.0 |  0.03
Output  | 3.3092e-05 | 3.3092e-05 | 3.3092e-05 |   0.0 |  0.00
Modify  | 0.062068   | 0.062068   | 0.062068   |   0.0 |  0.13
Other   |            | 0.005668   |            |       |  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:       212688 ave      212688 max      212688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212688
Ave neighs/atom = 106.344
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.817938228097, Press = -4.20182939421332
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -15993.695     -15993.695     -16072.378     -16072.378      304.51076      304.51076      36802.568      36802.568      1921.6019      1921.6019    
     21000  -15992.753     -15992.753     -16072.53      -16072.53       308.74379      308.74379      36859.795      36859.795     -1155.7974     -1155.7974    
Loop time of 46.6114 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.854 ns/day, 12.948 hours/ns, 21.454 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    | 46.529     | 46.529     | 46.529     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014908   | 0.014908   | 0.014908   |   0.0 |  0.03
Output  | 3.1589e-05 | 3.1589e-05 | 3.1589e-05 |   0.0 |  0.00
Modify  | 0.061832   | 0.061832   | 0.061832   |   0.0 |  0.13
Other   |            | 0.005647   |            |       |  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:       213296 ave      213296 max      213296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213296
Ave neighs/atom = 106.648
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.878573836685, Press = -3.58603060182837
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -15992.753     -15992.753     -16072.53      -16072.53       308.74379      308.74379      36859.795      36859.795     -1155.7974     -1155.7974    
     22000  -15994.245     -15994.245     -16069.726     -16069.726      292.11951      292.11951      36862.779      36862.779     -1155.9079     -1155.9079    
Loop time of 46.5187 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.857 ns/day, 12.922 hours/ns, 21.497 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    | 46.436     | 46.436     | 46.436     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015085   | 0.015085   | 0.015085   |   0.0 |  0.03
Output  | 2.8753e-05 | 2.8753e-05 | 2.8753e-05 |   0.0 |  0.00
Modify  | 0.061729   | 0.061729   | 0.061729   |   0.0 |  0.13
Other   |            | 0.005636   |            |       |  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:       212318 ave      212318 max      212318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212318
Ave neighs/atom = 106.159
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.872303818393, Press = -4.33554091022627
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -15994.245     -15994.245     -16069.726     -16069.726      292.11951      292.11951      36862.779      36862.779     -1155.9079     -1155.9079    
     23000  -15994.721     -15994.721     -16069.616     -16069.616      289.85065      289.85065      36812.817      36812.817      1475.1509      1475.1509    
Loop time of 46.5246 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.857 ns/day, 12.924 hours/ns, 21.494 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    | 46.442     | 46.442     | 46.442     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014975   | 0.014975   | 0.014975   |   0.0 |  0.03
Output  | 2.3063e-05 | 2.3063e-05 | 2.3063e-05 |   0.0 |  0.00
Modify  | 0.061645   | 0.061645   | 0.061645   |   0.0 |  0.13
Other   |            | 0.00563    |            |       |  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:       212460 ave      212460 max      212460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212460
Ave neighs/atom = 106.23
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.968475526316, Press = -1.18695891585037
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -15994.721     -15994.721     -16069.616     -16069.616      289.85065      289.85065      36812.817      36812.817      1475.1509      1475.1509    
     24000  -15992.153     -15992.153     -16073.449     -16073.449      314.62205      314.62205      36830.588      36830.588      337.52836      337.52836    
Loop time of 46.5161 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.857 ns/day, 12.921 hours/ns, 21.498 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    | 46.434     | 46.434     | 46.434     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014954   | 0.014954   | 0.014954   |   0.0 |  0.03
Output  | 4.7248e-05 | 4.7248e-05 | 4.7248e-05 |   0.0 |  0.00
Modify  | 0.061739   | 0.061739   | 0.061739   |   0.0 |  0.13
Other   |            | 0.005522   |            |       |  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:       212838 ave      212838 max      212838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212838
Ave neighs/atom = 106.419
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.041364412494, Press = -3.31573664889121
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -15992.153     -15992.153     -16073.449     -16073.449      314.62205      314.62205      36830.588      36830.588      337.52836      337.52836    
     25000  -15993.455     -15993.455     -16071.247     -16071.247      301.062        301.062        36810.274      36810.274      1540.5086      1540.5086    
Loop time of 46.5488 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.856 ns/day, 12.930 hours/ns, 21.483 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    | 46.467     | 46.467     | 46.467     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014993   | 0.014993   | 0.014993   |   0.0 |  0.03
Output  | 4.7118e-05 | 4.7118e-05 | 4.7118e-05 |   0.0 |  0.00
Modify  | 0.061784   | 0.061784   | 0.061784   |   0.0 |  0.13
Other   |            | 0.005497   |            |       |  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:       212896 ave      212896 max      212896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212896
Ave neighs/atom = 106.448
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.064270867159, Press = -2.14935112541072
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -15993.455     -15993.455     -16071.247     -16071.247      301.062        301.062        36810.274      36810.274      1540.5086      1540.5086    
     26000  -15997.493     -15997.493     -16070.054     -16070.054      280.81758      280.81758      36812.991      36812.991      1359.0544      1359.0544    
Loop time of 46.5397 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.856 ns/day, 12.928 hours/ns, 21.487 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    | 46.457     | 46.457     | 46.457     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01523    | 0.01523    | 0.01523    |   0.0 |  0.03
Output  | 4.4604e-05 | 4.4604e-05 | 4.4604e-05 |   0.0 |  0.00
Modify  | 0.061818   | 0.061818   | 0.061818   |   0.0 |  0.13
Other   |            | 0.005504   |            |       |  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:       213090 ave      213090 max      213090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213090
Ave neighs/atom = 106.545
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.143855292893, Press = -1.89126573291043
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -15997.493     -15997.493     -16070.054     -16070.054      280.81758      280.81758      36812.991      36812.991      1359.0544      1359.0544    
     27000  -15994.158     -15994.158     -16068.38      -16068.38       287.24637      287.24637      36871.72       36871.72      -1327.3547     -1327.3547    
Loop time of 46.5565 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.856 ns/day, 12.932 hours/ns, 21.479 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    | 46.474     | 46.474     | 46.474     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014935   | 0.014935   | 0.014935   |   0.0 |  0.03
Output  | 3.721e-05  | 3.721e-05  | 3.721e-05  |   0.0 |  0.00
Modify  | 0.061743   | 0.061743   | 0.061743   |   0.0 |  0.13
Other   |            | 0.005498   |            |       |  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:       212528 ave      212528 max      212528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212528
Ave neighs/atom = 106.264
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.124461169038, Press = -1.4324442295461
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -15994.158     -15994.158     -16068.38      -16068.38       287.24637      287.24637      36871.72       36871.72      -1327.3547     -1327.3547    
     28000  -15996.52      -15996.52      -16070.722     -16070.722      287.17169      287.17169      36881.314      36881.314     -2296.0468     -2296.0468    
Loop time of 46.5083 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.858 ns/day, 12.919 hours/ns, 21.502 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    | 46.426     | 46.426     | 46.426     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015086   | 0.015086   | 0.015086   |   0.0 |  0.03
Output  | 4.9673e-05 | 4.9673e-05 | 4.9673e-05 |   0.0 |  0.00
Modify  | 0.061764   | 0.061764   | 0.061764   |   0.0 |  0.13
Other   |            | 0.005499   |            |       |  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:       211902 ave      211902 max      211902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211902
Ave neighs/atom = 105.951
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.072726113189, Press = -2.55925037617407
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -15996.52      -15996.52      -16070.722     -16070.722      287.17169      287.17169      36881.314      36881.314     -2296.0468     -2296.0468    
     29000  -15992.835     -15992.835     -16069.739     -16069.739      297.62739      297.62739      36911.201      36911.201     -3644.8501     -3644.8501    
Loop time of 46.8845 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.843 ns/day, 13.023 hours/ns, 21.329 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    | 46.802     | 46.802     | 46.802     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015052   | 0.015052   | 0.015052   |   0.0 |  0.03
Output  | 6.6956e-05 | 6.6956e-05 | 6.6956e-05 |   0.0 |  0.00
Modify  | 0.062238   | 0.062238   | 0.062238   |   0.0 |  0.13
Other   |            | 0.005537   |            |       |  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:       212070 ave      212070 max      212070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212070
Ave neighs/atom = 106.035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.985353643751, Press = -4.41195648133334
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -15992.835     -15992.835     -16069.739     -16069.739      297.62739      297.62739      36911.201      36911.201     -3644.8501     -3644.8501    
     30000  -15991.027     -15991.027     -16067.882     -16067.882      297.43719      297.43719      36810.986      36810.986      1750.2013      1750.2013    
Loop time of 46.9681 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.840 ns/day, 13.047 hours/ns, 21.291 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    | 46.885     | 46.885     | 46.885     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015078   | 0.015078   | 0.015078   |   0.0 |  0.03
Output  | 4.5125e-05 | 4.5125e-05 | 4.5125e-05 |   0.0 |  0.00
Modify  | 0.062486   | 0.062486   | 0.062486   |   0.0 |  0.13
Other   |            | 0.005576   |            |       |  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:       211546 ave      211546 max      211546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211546
Ave neighs/atom = 105.773
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.052342618435, Press = -4.12629560172943
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -15991.027     -15991.027     -16067.882     -16067.882      297.43719      297.43719      36810.986      36810.986      1750.2013      1750.2013    
     31000  -15993.975     -15993.975     -16070.274     -16070.274      295.28649      295.28649      36793.722      36793.722      2520.6763      2520.6763    
Loop time of 46.7717 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.847 ns/day, 12.992 hours/ns, 21.380 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.689     | 46.689     | 46.689     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014964   | 0.014964   | 0.014964   |   0.0 |  0.03
Output  | 3.9925e-05 | 3.9925e-05 | 3.9925e-05 |   0.0 |  0.00
Modify  | 0.061978   | 0.061978   | 0.061978   |   0.0 |  0.13
Other   |            | 0.00553    |            |       |  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:       212600 ave      212600 max      212600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212600
Ave neighs/atom = 106.3
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.074632161148, Press = -0.849741006220153
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -15993.975     -15993.975     -16070.274     -16070.274      295.28649      295.28649      36793.722      36793.722      2520.6763      2520.6763    
     32000  -15988.542     -15988.542     -16066.948     -16066.948      303.43962      303.43962      36806.732      36806.732      2096.0045      2096.0045    
Loop time of 46.7107 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.850 ns/day, 12.975 hours/ns, 21.408 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    | 46.628     | 46.628     | 46.628     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015031   | 0.015031   | 0.015031   |   0.0 |  0.03
Output  | 5.0074e-05 | 5.0074e-05 | 5.0074e-05 |   0.0 |  0.00
Modify  | 0.061978   | 0.061978   | 0.061978   |   0.0 |  0.13
Other   |            | 0.00556    |            |       |  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:       213196 ave      213196 max      213196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213196
Ave neighs/atom = 106.598
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.143398797451, Press = -0.644646064989777
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -15988.542     -15988.542     -16066.948     -16066.948      303.43962      303.43962      36806.732      36806.732      2096.0045      2096.0045    
     33000  -15995.294     -15995.294     -16071.52      -16071.52       295.0031       295.0031       36843.95       36843.95      -285.2184      -285.2184     
Loop time of 46.6952 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.850 ns/day, 12.971 hours/ns, 21.415 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    | 46.612     | 46.612     | 46.612     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015177   | 0.015177   | 0.015177   |   0.0 |  0.03
Output  | 3.5867e-05 | 3.5867e-05 | 3.5867e-05 |   0.0 |  0.00
Modify  | 0.062105   | 0.062105   | 0.062105   |   0.0 |  0.13
Other   |            | 0.005542   |            |       |  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:       212720 ave      212720 max      212720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212720
Ave neighs/atom = 106.36
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.160403216086, Press = 0.216608292054739
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -15995.294     -15995.294     -16071.52      -16071.52       295.0031       295.0031       36843.95       36843.95      -285.2184      -285.2184     
     34000  -15996.231     -15996.231     -16072.184     -16072.184      293.94538      293.94538      36851.3        36851.3       -717.9152      -717.9152     
Loop time of 46.6715 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.851 ns/day, 12.964 hours/ns, 21.426 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.589     | 46.589     | 46.589     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015047   | 0.015047   | 0.015047   |   0.0 |  0.03
Output  | 6.8809e-05 | 6.8809e-05 | 6.8809e-05 |   0.0 |  0.00
Modify  | 0.062083   | 0.062083   | 0.062083   |   0.0 |  0.13
Other   |            | 0.005549   |            |       |  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:       212420 ave      212420 max      212420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212420
Ave neighs/atom = 106.21
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.188476442177, Press = -1.69052418771299
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -15996.231     -15996.231     -16072.184     -16072.184      293.94538      293.94538      36851.3        36851.3       -717.9152      -717.9152     
     35000  -15992.488     -15992.488     -16068.196     -16068.196      292.995        292.995        36867.704      36867.704     -1237.3958     -1237.3958    
Loop time of 46.707 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.850 ns/day, 12.974 hours/ns, 21.410 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    | 46.624     | 46.624     | 46.624     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015033   | 0.015033   | 0.015033   |   0.0 |  0.03
Output  | 4.4664e-05 | 4.4664e-05 | 4.4664e-05 |   0.0 |  0.00
Modify  | 0.062034   | 0.062034   | 0.062034   |   0.0 |  0.13
Other   |            | 0.005566   |            |       |  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:       212724 ave      212724 max      212724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212724
Ave neighs/atom = 106.362
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.167807099436, Press = -0.966868437182615
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -15992.488     -15992.488     -16068.196     -16068.196      292.995        292.995        36867.704      36867.704     -1237.3958     -1237.3958    
     36000  -15996.341     -15996.341     -16070.517     -16070.517      287.06844      287.06844      36853.102      36853.102     -763.1098      -763.1098     
Loop time of 46.7353 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.849 ns/day, 12.982 hours/ns, 21.397 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    | 46.652     | 46.652     | 46.652     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01503    | 0.01503    | 0.01503    |   0.0 |  0.03
Output  | 3.4595e-05 | 3.4595e-05 | 3.4595e-05 |   0.0 |  0.00
Modify  | 0.062196   | 0.062196   | 0.062196   |   0.0 |  0.13
Other   |            | 0.005545   |            |       |  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:       212072 ave      212072 max      212072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212072
Ave neighs/atom = 106.036
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.15164000154, Press = -2.60261179227345
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -15996.341     -15996.341     -16070.517     -16070.517      287.06844      287.06844      36853.102      36853.102     -763.1098      -763.1098     
     37000  -15993.728     -15993.728     -16069.252     -16069.252      292.28573      292.28573      36855.356      36855.356     -672.952       -672.952      
Loop time of 46.7554 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.848 ns/day, 12.988 hours/ns, 21.388 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.673     | 46.673     | 46.673     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015075   | 0.015075   | 0.015075   |   0.0 |  0.03
Output  | 4.8201e-05 | 4.8201e-05 | 4.8201e-05 |   0.0 |  0.00
Modify  | 0.062064   | 0.062064   | 0.062064   |   0.0 |  0.13
Other   |            | 0.005571   |            |       |  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:       212246 ave      212246 max      212246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212246
Ave neighs/atom = 106.123
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.14788271636, Press = -2.49359914184168
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -15993.728     -15993.728     -16069.252     -16069.252      292.28573      292.28573      36855.356      36855.356     -672.952       -672.952      
     38000  -15994.231     -15994.231     -16071.864     -16071.864      300.44694      300.44694      36785.447      36785.447      2615.1524      2615.1524    
Loop time of 46.7801 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.847 ns/day, 12.994 hours/ns, 21.377 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.697     | 46.697     | 46.697     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015095   | 0.015095   | 0.015095   |   0.0 |  0.03
Output  | 4.3441e-05 | 4.3441e-05 | 4.3441e-05 |   0.0 |  0.00
Modify  | 0.062118   | 0.062118   | 0.062118   |   0.0 |  0.13
Other   |            | 0.005567   |            |       |  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:       212034 ave      212034 max      212034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212034
Ave neighs/atom = 106.017
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.178006621409, Press = -1.80866042664912
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -15994.231     -15994.231     -16071.864     -16071.864      300.44694      300.44694      36785.447      36785.447      2615.1524      2615.1524    
     39000  -15991.466     -15991.466     -16070.198     -16070.198      304.69886      304.69886      36823.861      36823.861      1057.2745      1057.2745    
Loop time of 46.731 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.849 ns/day, 12.981 hours/ns, 21.399 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.648     | 46.648     | 46.648     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014963   | 0.014963   | 0.014963   |   0.0 |  0.03
Output  | 4.7189e-05 | 4.7189e-05 | 4.7189e-05 |   0.0 |  0.00
Modify  | 0.062019   | 0.062019   | 0.062019   |   0.0 |  0.13
Other   |            | 0.005543   |            |       |  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:       213146 ave      213146 max      213146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213146
Ave neighs/atom = 106.573
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.205025371775, Press = -0.992698960795266
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -15991.466     -15991.466     -16070.198     -16070.198      304.69886      304.69886      36823.861      36823.861      1057.2745      1057.2745    
     40000  -15996.939     -15996.939     -16070.979     -16070.979      286.54037      286.54037      36836.434      36836.434     -15.94089      -15.94089     
Loop time of 46.6854 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.851 ns/day, 12.968 hours/ns, 21.420 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.603     | 46.603     | 46.603     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015099   | 0.015099   | 0.015099   |   0.0 |  0.03
Output  | 3.5496e-05 | 3.5496e-05 | 3.5496e-05 |   0.0 |  0.00
Modify  | 0.062104   | 0.062104   | 0.062104   |   0.0 |  0.13
Other   |            | 0.005582   |            |       |  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:       212576 ave      212576 max      212576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212576
Ave neighs/atom = 106.288
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.153419027865, Press = -1.33149834493595
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -15996.939     -15996.939     -16070.979     -16070.979      286.54037      286.54037      36836.434      36836.434     -15.94089      -15.94089     
     41000  -15993.724     -15993.724     -16069.854     -16069.854      294.63128      294.63128      36842.798      36842.798     -126.6856      -126.6856     
Loop time of 46.6853 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.851 ns/day, 12.968 hours/ns, 21.420 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.603     | 46.603     | 46.603     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014962   | 0.014962   | 0.014962   |   0.0 |  0.03
Output  | 4.8801e-05 | 4.8801e-05 | 4.8801e-05 |   0.0 |  0.00
Modify  | 0.062153   | 0.062153   | 0.062153   |   0.0 |  0.13
Other   |            | 0.005543   |            |       |  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:       212636 ave      212636 max      212636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212636
Ave neighs/atom = 106.318
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.110906061369, Press = -0.436016273274131
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -15993.724     -15993.724     -16069.854     -16069.854      294.63128      294.63128      36842.798      36842.798     -126.6856      -126.6856     
     42000  -15995.736     -15995.736     -16071.569     -16071.569      293.47974      293.47974      36861.661      36861.661     -1251.1582     -1251.1582    
Loop time of 46.6655 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.851 ns/day, 12.963 hours/ns, 21.429 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.583     | 46.583     | 46.583     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01517    | 0.01517    | 0.01517    |   0.0 |  0.03
Output  | 3.4835e-05 | 3.4835e-05 | 3.4835e-05 |   0.0 |  0.00
Modify  | 0.061984   | 0.061984   | 0.061984   |   0.0 |  0.13
Other   |            | 0.005535   |            |       |  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:       212348 ave      212348 max      212348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212348
Ave neighs/atom = 106.174
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.114002020232, Press = -1.36037722515569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -15995.736     -15995.736     -16071.569     -16071.569      293.47974      293.47974      36861.661      36861.661     -1251.1582     -1251.1582    
     43000  -15992.574     -15992.574     -16072.868     -16072.868      310.74635      310.74635      36865.789      36865.789     -1545.7712     -1545.7712    
Loop time of 46.6877 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.851 ns/day, 12.969 hours/ns, 21.419 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.605     | 46.605     | 46.605     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014988   | 0.014988   | 0.014988   |   0.0 |  0.03
Output  | 4.6037e-05 | 4.6037e-05 | 4.6037e-05 |   0.0 |  0.00
Modify  | 0.062098   | 0.062098   | 0.062098   |   0.0 |  0.13
Other   |            | 0.005569   |            |       |  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:       212352 ave      212352 max      212352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212352
Ave neighs/atom = 106.176
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.145032739776, Press = -1.89392490900485
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -15992.574     -15992.574     -16072.868     -16072.868      310.74635      310.74635      36865.789      36865.789     -1545.7712     -1545.7712    
     44000  -15995.978     -15995.978     -16070.464     -16070.464      288.26906      288.26906      36837.317      36837.317      154.70295      154.70295    
Loop time of 46.7297 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.849 ns/day, 12.980 hours/ns, 21.400 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.647     | 46.647     | 46.647     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01499    | 0.01499    | 0.01499    |   0.0 |  0.03
Output  | 4.5516e-05 | 4.5516e-05 | 4.5516e-05 |   0.0 |  0.00
Modify  | 0.062096   | 0.062096   | 0.062096   |   0.0 |  0.13
Other   |            | 0.005564   |            |       |  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:       212588 ave      212588 max      212588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212588
Ave neighs/atom = 106.294
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.193209972134, Press = -2.06276475067476
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -15995.978     -15995.978     -16070.464     -16070.464      288.26906      288.26906      36837.317      36837.317      154.70295      154.70295    
     45000  -15993.101     -15993.101     -16068.749     -16068.749      292.76567      292.76567      36836.093      36836.093      264.034        264.034      
Loop time of 46.7458 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.848 ns/day, 12.985 hours/ns, 21.392 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.663     | 46.663     | 46.663     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015017   | 0.015017   | 0.015017   |   0.0 |  0.03
Output  | 3.722e-05  | 3.722e-05  | 3.722e-05  |   0.0 |  0.00
Modify  | 0.062182   | 0.062182   | 0.062182   |   0.0 |  0.13
Other   |            | 0.005537   |            |       |  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:       212566 ave      212566 max      212566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212566
Ave neighs/atom = 106.283
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.237674471491, Press = -1.31197315230074
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -15993.101     -15993.101     -16068.749     -16068.749      292.76567      292.76567      36836.093      36836.093      264.034        264.034      
     46000  -15992.743     -15992.743     -16069.92      -16069.92       298.68185      298.68185      36880.92       36880.92      -2059.2284     -2059.2284    
Loop time of 46.7065 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.850 ns/day, 12.974 hours/ns, 21.410 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.624     | 46.624     | 46.624     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015158   | 0.015158   | 0.015158   |   0.0 |  0.03
Output  | 5.1116e-05 | 5.1116e-05 | 5.1116e-05 |   0.0 |  0.00
Modify  | 0.062159   | 0.062159   | 0.062159   |   0.0 |  0.13
Other   |            | 0.005577   |            |       |  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:       212492 ave      212492 max      212492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212492
Ave neighs/atom = 106.246
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.265044457255, Press = -2.46981704828675
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -15992.743     -15992.743     -16069.92      -16069.92       298.68185      298.68185      36880.92       36880.92      -2059.2284     -2059.2284    
     47000  -15996.732     -15996.732     -16071.542     -16071.542      289.52264      289.52264      36809.351      36809.351      1522.7669      1522.7669    
Loop time of 46.5857 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.855 ns/day, 12.940 hours/ns, 21.466 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.503     | 46.503     | 46.503     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015073   | 0.015073   | 0.015073   |   0.0 |  0.03
Output  | 5.0084e-05 | 5.0084e-05 | 5.0084e-05 |   0.0 |  0.00
Modify  | 0.061993   | 0.061993   | 0.061993   |   0.0 |  0.13
Other   |            | 0.005546   |            |       |  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:       212098 ave      212098 max      212098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212098
Ave neighs/atom = 106.049
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.282741346594, Press = -2.13445981238255
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -15996.732     -15996.732     -16071.542     -16071.542      289.52264      289.52264      36809.351      36809.351      1522.7669      1522.7669    
     48000  -15993.213     -15993.213     -16071.187     -16071.187      301.76601      301.76601      36808.246      36808.246      1563.6762      1563.6762    
Loop time of 46.6171 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.853 ns/day, 12.949 hours/ns, 21.451 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.535     | 46.535     | 46.535     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014953   | 0.014953   | 0.014953   |   0.0 |  0.03
Output  | 4.5245e-05 | 4.5245e-05 | 4.5245e-05 |   0.0 |  0.00
Modify  | 0.061941   | 0.061941   | 0.061941   |   0.0 |  0.13
Other   |            | 0.005554   |            |       |  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:       213042 ave      213042 max      213042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213042
Ave neighs/atom = 106.521
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.28696378123, Press = -1.34933817873932
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -15993.213     -15993.213     -16071.187     -16071.187      301.76601      301.76601      36808.246      36808.246      1563.6762      1563.6762    
     49000  -15994.604     -15994.604     -16070.302     -16070.302      292.96063      292.96063      36827.052      36827.052      559.82199      559.82199    
Loop time of 46.6161 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.853 ns/day, 12.949 hours/ns, 21.452 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.534     | 46.534     | 46.534     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015063   | 0.015063   | 0.015063   |   0.0 |  0.03
Output  | 3.5967e-05 | 3.5967e-05 | 3.5967e-05 |   0.0 |  0.00
Modify  | 0.061906   | 0.061906   | 0.061906   |   0.0 |  0.13
Other   |            | 0.005536   |            |       |  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:       212936 ave      212936 max      212936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212936
Ave neighs/atom = 106.468
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.270174448149, Press = -0.803681665424324
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -15994.604     -15994.604     -16070.302     -16070.302      292.96063      292.96063      36827.052      36827.052      559.82199      559.82199    
     50000  -15992.551     -15992.551     -16069.296     -16069.296      297.01237      297.01237      36842.108      36842.108     -29.514311     -29.514311    
Loop time of 46.5562 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.856 ns/day, 12.932 hours/ns, 21.479 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.474     | 46.474     | 46.474     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015076   | 0.015076   | 0.015076   |   0.0 |  0.03
Output  | 4.9734e-05 | 4.9734e-05 | 4.9734e-05 |   0.0 |  0.00
Modify  | 0.06189    | 0.06189    | 0.06189    |   0.0 |  0.13
Other   |            | 0.005521   |            |       |  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:       212792 ave      212792 max      212792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212792
Ave neighs/atom = 106.396
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.250326075422, Press = -1.18678275297787
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -15992.551     -15992.551     -16069.296     -16069.296      297.01237      297.01237      36842.108      36842.108     -29.514311     -29.514311    
     51000  -15992.831     -15992.831     -16068.782     -16068.782      293.93998      293.93998      36830.29       36830.29       525.66295      525.66295    
Loop time of 46.5374 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.857 ns/day, 12.927 hours/ns, 21.488 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.455     | 46.455     | 46.455     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014948   | 0.014948   | 0.014948   |   0.0 |  0.03
Output  | 4.6267e-05 | 4.6267e-05 | 4.6267e-05 |   0.0 |  0.00
Modify  | 0.061867   | 0.061867   | 0.061867   |   0.0 |  0.13
Other   |            | 0.005531   |            |       |  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:       212404 ave      212404 max      212404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212404
Ave neighs/atom = 106.202
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.258350733761, Press = -0.840108110896331
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -15992.831     -15992.831     -16068.782     -16068.782      293.93998      293.93998      36830.29       36830.29       525.66295      525.66295    
     52000  -15995.889     -15995.889     -16070.546     -16070.546      288.92876      288.92876      36853.57       36853.57      -837.40418     -837.40418    
Loop time of 46.5835 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.855 ns/day, 12.940 hours/ns, 21.467 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.501     | 46.501     | 46.501     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015019   | 0.015019   | 0.015019   |   0.0 |  0.03
Output  | 4.4584e-05 | 4.4584e-05 | 4.4584e-05 |   0.0 |  0.00
Modify  | 0.061906   | 0.061906   | 0.061906   |   0.0 |  0.13
Other   |            | 0.005537   |            |       |  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:       212444 ave      212444 max      212444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212444
Ave neighs/atom = 106.222
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.220616804804, Press = -1.60863910395651
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -15995.889     -15995.889     -16070.546     -16070.546      288.92876      288.92876      36853.57       36853.57      -837.40418     -837.40418    
     53000  -15993.202     -15993.202     -16072.568     -16072.568      307.1555       307.1555       36824.365      36824.365      703.46317      703.46317    
Loop time of 46.5714 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.855 ns/day, 12.936 hours/ns, 21.472 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.489     | 46.489     | 46.489     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014914   | 0.014914   | 0.014914   |   0.0 |  0.03
Output  | 4.5104e-05 | 4.5104e-05 | 4.5104e-05 |   0.0 |  0.00
Modify  | 0.061992   | 0.061992   | 0.061992   |   0.0 |  0.13
Other   |            | 0.005533   |            |       |  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:       212318 ave      212318 max      212318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212318
Ave neighs/atom = 106.159
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.230755138963, Press = -1.94702426267615
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -15993.202     -15993.202     -16072.568     -16072.568      307.1555       307.1555       36824.365      36824.365      703.46317      703.46317    
     54000  -15994.678     -15994.678     -16070.495     -16070.495      293.41974      293.41974      36795.818      36795.818      2235.118       2235.118     
Loop time of 46.6037 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.854 ns/day, 12.945 hours/ns, 21.458 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.521     | 46.521     | 46.521     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015004   | 0.015004   | 0.015004   |   0.0 |  0.03
Output  | 3.5487e-05 | 3.5487e-05 | 3.5487e-05 |   0.0 |  0.00
Modify  | 0.061901   | 0.061901   | 0.061901   |   0.0 |  0.13
Other   |            | 0.005513   |            |       |  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:       212850 ave      212850 max      212850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212850
Ave neighs/atom = 106.425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.25905385071, Press = -1.24443474016385
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -15994.678     -15994.678     -16070.495     -16070.495      293.41974      293.41974      36795.818      36795.818      2235.118       2235.118     
     55000  -15997.648     -15997.648     -16071.946     -16071.946      287.54123      287.54123      36785.042      36785.042      2731.4669      2731.4669    
Loop time of 46.5888 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.855 ns/day, 12.941 hours/ns, 21.464 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.506     | 46.506     | 46.506     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015085   | 0.015085   | 0.015085   |   0.0 |  0.03
Output  | 4.9182e-05 | 4.9182e-05 | 4.9182e-05 |   0.0 |  0.00
Modify  | 0.061878   | 0.061878   | 0.061878   |   0.0 |  0.13
Other   |            | 0.00553    |            |       |  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:       212968 ave      212968 max      212968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0