# 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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  -16076.341     -16076.341     -16146.92      -16146.92       273.15         273.15         36708.262      36708.262      2053.6787      2053.6787    
      1000  -16002.469     -16002.469     -16073.265     -16073.265      273.98751      273.98751      36826.312      36826.312      389.59186      389.59186    
Loop time of 46.6645 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.852 ns/day, 12.962 hours/ns, 21.430 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.582     | 46.582     | 46.582     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015253   | 0.015253   | 0.015253   |   0.0 |  0.03
Output  | 0.00011275 | 0.00011275 | 0.00011275 |   0.0 |  0.00
Modify  | 0.061631   | 0.061631   | 0.061631   |   0.0 |  0.13
Other   |            | 0.005591   |            |       |  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:       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  -16002.469     -16002.469     -16073.265     -16073.265      273.98751      273.98751      36826.312      36826.312      389.59186      389.59186    
      2000  -16003.526     -16003.526     -16074.941     -16074.941      276.38386      276.38386      36876.277      36876.277     -2501.1731     -2501.1731    
Loop time of 46.6532 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.852 ns/day, 12.959 hours/ns, 21.435 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.573     | 46.573     | 46.573     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014912   | 0.014912   | 0.014912   |   0.0 |  0.03
Output  | 3.9885e-05 | 3.9885e-05 | 3.9885e-05 |   0.0 |  0.00
Modify  | 0.060152   | 0.060152   | 0.060152   |   0.0 |  0.13
Other   |            | 0.005204   |            |       |  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:       213126 ave      213126 max      213126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213126
Ave neighs/atom = 106.563
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  -16003.526     -16003.526     -16074.941     -16074.941      276.38386      276.38386      36876.277      36876.277     -2501.1731     -2501.1731    
      3000  -16004.63      -16004.63      -16075.48      -16075.48       274.19408      274.19408      36794.969      36794.969      1624.3972      1624.3972    
Loop time of 46.5544 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.856 ns/day, 12.932 hours/ns, 21.480 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.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015015   | 0.015015   | 0.015015   |   0.0 |  0.03
Output  | 3.6979e-05 | 3.6979e-05 | 3.6979e-05 |   0.0 |  0.00
Modify  | 0.060359   | 0.060359   | 0.060359   |   0.0 |  0.13
Other   |            | 0.005161   |            |       |  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:       212620 ave      212620 max      212620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212620
Ave neighs/atom = 106.31
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  -16004.63      -16004.63      -16075.48      -16075.48       274.19408      274.19408      36794.969      36794.969      1624.3972      1624.3972    
      4000  -16006.928     -16006.928     -16078.433     -16078.433      276.7308       276.7308       36797.322      36797.322      1054.5674      1054.5674    
Loop time of 46.5688 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.855 ns/day, 12.936 hours/ns, 21.474 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.489     | 46.489     | 46.489     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014903   | 0.014903   | 0.014903   |   0.0 |  0.03
Output  | 4.276e-05  | 4.276e-05  | 4.276e-05  |   0.0 |  0.00
Modify  | 0.059793   | 0.059793   | 0.059793   |   0.0 |  0.13
Other   |            | 0.005174   |            |       |  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:       213270 ave      213270 max      213270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213270
Ave neighs/atom = 106.635
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  -16006.928     -16006.928     -16078.433     -16078.433      276.7308       276.7308       36797.322      36797.322      1054.5674      1054.5674    
      5000  -16003.006     -16003.006     -16079.467     -16079.467      295.91512      295.91512      36851.984      36851.984     -1551.6168     -1551.6168    
Loop time of 46.5533 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.856 ns/day, 12.931 hours/ns, 21.481 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.473     | 46.473     | 46.473     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014941   | 0.014941   | 0.014941   |   0.0 |  0.03
Output  | 3.4284e-05 | 3.4284e-05 | 3.4284e-05 |   0.0 |  0.00
Modify  | 0.060271   | 0.060271   | 0.060271   |   0.0 |  0.13
Other   |            | 0.005169   |            |       |  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:       213250 ave      213250 max      213250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213250
Ave neighs/atom = 106.625
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 = 272.720133138189, Press = 318.550104275354
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  -16003.006     -16003.006     -16079.467     -16079.467      295.91512      295.91512      36851.984      36851.984     -1551.6168     -1551.6168    
      6000  -16004.848     -16004.848     -16080.325     -16080.325      292.10636      292.10636      36835.97       36835.97      -949.2691      -949.2691     
Loop time of 46.5166 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.857 ns/day, 12.921 hours/ns, 21.498 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.434     | 46.434     | 46.434     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014917   | 0.014917   | 0.014917   |   0.0 |  0.03
Output  | 3.3082e-05 | 3.3082e-05 | 3.3082e-05 |   0.0 |  0.00
Modify  | 0.062352   | 0.062352   | 0.062352   |   0.0 |  0.13
Other   |            | 0.00522    |            |       |  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:       213022 ave      213022 max      213022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213022
Ave neighs/atom = 106.511
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 = 273.761192524972, Press = -29.3229465515558
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  -16004.848     -16004.848     -16080.325     -16080.325      292.10636      292.10636      36835.97       36835.97      -949.2691      -949.2691     
      7000  -16007.571     -16007.571     -16074.064     -16074.064      257.33566      257.33566      36832.313      36832.313     -209.73117     -209.73117    
Loop time of 46.58 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.855 ns/day, 12.939 hours/ns, 21.468 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.497     | 46.497     | 46.497     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015046   | 0.015046   | 0.015046   |   0.0 |  0.03
Output  | 3.1469e-05 | 3.1469e-05 | 3.1469e-05 |   0.0 |  0.00
Modify  | 0.062262   | 0.062262   | 0.062262   |   0.0 |  0.13
Other   |            | 0.005215   |            |       |  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:       213272 ave      213272 max      213272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213272
Ave neighs/atom = 106.636
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 = 273.197471250828, Press = 31.2835765060882
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  -16007.571     -16007.571     -16074.064     -16074.064      257.33566      257.33566      36832.313      36832.313     -209.73117     -209.73117    
      8000  -16003.656     -16003.656     -16078.501     -16078.501      289.65906      289.65906      36809.255      36809.255      602.04193      602.04193    
Loop time of 46.4769 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.859 ns/day, 12.910 hours/ns, 21.516 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.395     | 46.395     | 46.395     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014849   | 0.014849   | 0.014849   |   0.0 |  0.03
Output  | 2.1862e-05 | 2.1862e-05 | 2.1862e-05 |   0.0 |  0.00
Modify  | 0.061978   | 0.061978   | 0.061978   |   0.0 |  0.13
Other   |            | 0.005192   |            |       |  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:       212506 ave      212506 max      212506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212506
Ave neighs/atom = 106.253
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 = 273.358125819343, Press = -1.73930243550322
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  -16003.656     -16003.656     -16078.501     -16078.501      289.65906      289.65906      36809.255      36809.255      602.04193      602.04193    
      9000  -16006.798     -16006.798     -16076.317     -16076.317      269.04529      269.04529      36845.61       36845.61      -1199.1152     -1199.1152    
Loop time of 46.5178 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.857 ns/day, 12.922 hours/ns, 21.497 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.435     | 46.435     | 46.435     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014932   | 0.014932   | 0.014932   |   0.0 |  0.03
Output  | 3.718e-05  | 3.718e-05  | 3.718e-05  |   0.0 |  0.00
Modify  | 0.062283   | 0.062283   | 0.062283   |   0.0 |  0.13
Other   |            | 0.005233   |            |       |  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:       213512 ave      213512 max      213512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213512
Ave neighs/atom = 106.756
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 = 273.616125616534, Press = 9.73909832314608
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  -16006.798     -16006.798     -16076.317     -16076.317      269.04529      269.04529      36845.61       36845.61      -1199.1152     -1199.1152    
     10000  -16003.791     -16003.791     -16079.302     -16079.302      292.23332      292.23332      36809.99       36809.99       598.42559      598.42559    
Loop time of 46.4954 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.858 ns/day, 12.915 hours/ns, 21.508 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.413     | 46.413     | 46.413     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014885   | 0.014885   | 0.014885   |   0.0 |  0.03
Output  | 3.6278e-05 | 3.6278e-05 | 3.6278e-05 |   0.0 |  0.00
Modify  | 0.062102   | 0.062102   | 0.062102   |   0.0 |  0.13
Other   |            | 0.005234   |            |       |  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:       212920 ave      212920 max      212920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212920
Ave neighs/atom = 106.46
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 = 273.163044651138, Press = -5.97063723616465
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  -16003.791     -16003.791     -16079.302     -16079.302      292.23332      292.23332      36809.99       36809.99       598.42559      598.42559    
     11000  -16004.47      -16004.47      -16071.793     -16071.793      260.54842      260.54842      36799.814      36799.814      1509.1724      1509.1724    
Loop time of 46.5615 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.856 ns/day, 12.934 hours/ns, 21.477 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.479     | 46.479     | 46.479     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014892   | 0.014892   | 0.014892   |   0.0 |  0.03
Output  | 3.0677e-05 | 3.0677e-05 | 3.0677e-05 |   0.0 |  0.00
Modify  | 0.062434   | 0.062434   | 0.062434   |   0.0 |  0.13
Other   |            | 0.005233   |            |       |  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:       213834 ave      213834 max      213834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213834
Ave neighs/atom = 106.917
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 = 273.28578435925, Press = 5.65119124492842
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  -16004.47      -16004.47      -16071.793     -16071.793      260.54842      260.54842      36799.814      36799.814      1509.1724      1509.1724    
     12000  -16003.353     -16003.353     -16077.94      -16077.94       288.66093      288.66093      36809.604      36809.604      844.09868      844.09868    
Loop time of 46.5355 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.857 ns/day, 12.927 hours/ns, 21.489 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.453     | 46.453     | 46.453     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014891   | 0.014891   | 0.014891   |   0.0 |  0.03
Output  | 2.8934e-05 | 2.8934e-05 | 2.8934e-05 |   0.0 |  0.00
Modify  | 0.062128   | 0.062128   | 0.062128   |   0.0 |  0.13
Other   |            | 0.005223   |            |       |  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:       213400 ave      213400 max      213400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213400
Ave neighs/atom = 106.7
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 = 273.391662193667, Press = 8.08395544615064
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  -16003.353     -16003.353     -16077.94      -16077.94       288.66093      288.66093      36809.604      36809.604      844.09868      844.09868    
     13000  -16004.957     -16004.957     -16075.964     -16075.964      274.80332      274.80332      36856.082      36856.082     -1729.6884     -1729.6884    
Loop time of 46.5402 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.856 ns/day, 12.928 hours/ns, 21.487 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.458     | 46.458     | 46.458     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014962   | 0.014962   | 0.014962   |   0.0 |  0.03
Output  | 2.1901e-05 | 2.1901e-05 | 2.1901e-05 |   0.0 |  0.00
Modify  | 0.062141   | 0.062141   | 0.062141   |   0.0 |  0.13
Other   |            | 0.005209   |            |       |  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:       213434 ave      213434 max      213434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213434
Ave neighs/atom = 106.717
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 = 273.399869010265, Press = 0.00283084544596273
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  -16004.957     -16004.957     -16075.964     -16075.964      274.80332      274.80332      36856.082      36856.082     -1729.6884     -1729.6884    
     14000  -16002.431     -16002.431     -16072.276     -16072.276      270.30825      270.30825      36861.097      36861.097     -1355.4966     -1355.4966    
Loop time of 46.554 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.856 ns/day, 12.932 hours/ns, 21.480 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.472     | 46.472     | 46.472     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014958   | 0.014958   | 0.014958   |   0.0 |  0.03
Output  | 3.6599e-05 | 3.6599e-05 | 3.6599e-05 |   0.0 |  0.00
Modify  | 0.061986   | 0.061986   | 0.061986   |   0.0 |  0.13
Other   |            | 0.0052     |            |       |  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:       212658 ave      212658 max      212658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212658
Ave neighs/atom = 106.329
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 = 273.360533256495, Press = 2.19364319198112
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  -16002.431     -16002.431     -16072.276     -16072.276      270.30825      270.30825      36861.097      36861.097     -1355.4966     -1355.4966    
     15000  -16003.247     -16003.247     -16077.206     -16077.206      286.22889      286.22889      36775.213      36775.213      2565.1011      2565.1011    
Loop time of 46.4989 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.858 ns/day, 12.916 hours/ns, 21.506 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.417     | 46.417     | 46.417     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014971   | 0.014971   | 0.014971   |   0.0 |  0.03
Output  | 3.1349e-05 | 3.1349e-05 | 3.1349e-05 |   0.0 |  0.00
Modify  | 0.061888   | 0.061888   | 0.061888   |   0.0 |  0.13
Other   |            | 0.005205   |            |       |  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:       212464 ave      212464 max      212464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212464
Ave neighs/atom = 106.232
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 = 273.329160646953, Press = -0.761718871615854
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  -16003.247     -16003.247     -16077.206     -16077.206      286.22889      286.22889      36775.213      36775.213      2565.1011      2565.1011    
     16000  -16003.571     -16003.571     -16075.599     -16075.599      278.75728      278.75728      36836.607      36836.607     -605.25112     -605.25112    
Loop time of 46.4861 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.404     | 46.404     | 46.404     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01488    | 0.01488    | 0.01488    |   0.0 |  0.03
Output  | 3.191e-05  | 3.191e-05  | 3.191e-05  |   0.0 |  0.00
Modify  | 0.062073   | 0.062073   | 0.062073   |   0.0 |  0.13
Other   |            | 0.005209   |            |       |  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:       213728 ave      213728 max      213728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213728
Ave neighs/atom = 106.864
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 = 273.251497050174, Press = 3.46045731591366
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  -16003.571     -16003.571     -16075.599     -16075.599      278.75728      278.75728      36836.607      36836.607     -605.25112     -605.25112    
     17000  -16005.239     -16005.239     -16073.32      -16073.32       263.47947      263.47947      36851.683      36851.683     -1228.4945     -1228.4945    
Loop time of 46.5279 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.857 ns/day, 12.924 hours/ns, 21.493 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.445     | 46.445     | 46.445     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014907   | 0.014907   | 0.014907   |   0.0 |  0.03
Output  | 2.2412e-05 | 2.2412e-05 | 2.2412e-05 |   0.0 |  0.00
Modify  | 0.062453   | 0.062453   | 0.062453   |   0.0 |  0.13
Other   |            | 0.005208   |            |       |  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:       212898 ave      212898 max      212898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212898
Ave neighs/atom = 106.449
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 = 273.407493287793, Press = 0.403310061848345
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  -16005.239     -16005.239     -16073.32      -16073.32       263.47947      263.47947      36851.683      36851.683     -1228.4945     -1228.4945    
     18000  -16004.317     -16004.317     -16080.297     -16080.297      294.05131      294.05131      36830.569      36830.569     -644.60925     -644.60925    
Loop time of 46.6372 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.853 ns/day, 12.955 hours/ns, 21.442 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.555     | 46.555     | 46.555     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014898   | 0.014898   | 0.014898   |   0.0 |  0.03
Output  | 3.5156e-05 | 3.5156e-05 | 3.5156e-05 |   0.0 |  0.00
Modify  | 0.062033   | 0.062033   | 0.062033   |   0.0 |  0.13
Other   |            | 0.00522    |            |       |  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:       212672 ave      212672 max      212672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212672
Ave neighs/atom = 106.336
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.296216196295, Press = -0.58466439436767
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  -16004.317     -16004.317     -16080.297     -16080.297      294.05131      294.05131      36830.569      36830.569     -644.60925     -644.60925    
     19000  -16005.574     -16005.574     -16077.956     -16077.956      280.12792      280.12792      36768.909      36768.909      2588.8168      2588.8168    
Loop time of 46.7154 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.849 ns/day, 12.977 hours/ns, 21.406 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.633     | 46.633     | 46.633     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015038   | 0.015038   | 0.015038   |   0.0 |  0.03
Output  | 3.5937e-05 | 3.5937e-05 | 3.5937e-05 |   0.0 |  0.00
Modify  | 0.062398   | 0.062398   | 0.062398   |   0.0 |  0.13
Other   |            | 0.005231   |            |       |  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:       213230 ave      213230 max      213230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213230
Ave neighs/atom = 106.615
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 = 273.381966171413, Press = 2.67286076061542
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  -16005.574     -16005.574     -16077.956     -16077.956      280.12792      280.12792      36768.909      36768.909      2588.8168      2588.8168    
     20000  -16003.798     -16003.798     -16078.031     -16078.031      287.28828      287.28828      36843.07       36843.07      -916.71971     -916.71971    
Loop time of 46.6362 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.853 ns/day, 12.955 hours/ns, 21.443 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.554     | 46.554     | 46.554     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014902   | 0.014902   | 0.014902   |   0.0 |  0.03
Output  | 3.1479e-05 | 3.1479e-05 | 3.1479e-05 |   0.0 |  0.00
Modify  | 0.062226   | 0.062226   | 0.062226   |   0.0 |  0.13
Other   |            | 0.005218   |            |       |  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:       213714 ave      213714 max      213714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213714
Ave neighs/atom = 106.857
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 = 273.296525760486, Press = 3.10113118504504
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  -16003.798     -16003.798     -16078.031     -16078.031      287.28828      287.28828      36843.07       36843.07      -916.71971     -916.71971    
     21000  -16005.025     -16005.025     -16076.394     -16076.394      276.20715      276.20715      36839.102      36839.102     -823.10039     -823.10039    
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.014912   | 0.014912   | 0.014912   |   0.0 |  0.03
Output  | 2.7492e-05 | 2.7492e-05 | 2.7492e-05 |   0.0 |  0.00
Modify  | 0.062365   | 0.062365   | 0.062365   |   0.0 |  0.13
Other   |            | 0.00524    |            |       |  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:       213084 ave      213084 max      213084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213084
Ave neighs/atom = 106.542
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 = 273.19866945264, Press = -3.21479214264664
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  -16005.025     -16005.025     -16076.394     -16076.394      276.20715      276.20715      36839.102      36839.102     -823.10039     -823.10039    
     22000  -16004.879     -16004.879     -16074.922     -16074.922      271.07612      271.07612      36797.093      36797.093      1605.0458      1605.0458    
Loop time of 46.6604 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.852 ns/day, 12.961 hours/ns, 21.431 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.578     | 46.578     | 46.578     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014873   | 0.014873   | 0.014873   |   0.0 |  0.03
Output  | 2.1731e-05 | 2.1731e-05 | 2.1731e-05 |   0.0 |  0.00
Modify  | 0.061897   | 0.061897   | 0.061897   |   0.0 |  0.13
Other   |            | 0.005206   |            |       |  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:       213052 ave      213052 max      213052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213052
Ave neighs/atom = 106.526
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 = 273.181585938631, Press = 2.81763863558003
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  -16004.879     -16004.879     -16074.922     -16074.922      271.07612      271.07612      36797.093      36797.093      1605.0458      1605.0458    
     23000  -16004.572     -16004.572     -16072.341     -16072.341      262.27317      262.27317      36874.495      36874.495     -2350.5263     -2350.5263    
Loop time of 46.7663 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.847 ns/day, 12.991 hours/ns, 21.383 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.683     | 46.683     | 46.683     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015049   | 0.015049   | 0.015049   |   0.0 |  0.03
Output  | 3.6569e-05 | 3.6569e-05 | 3.6569e-05 |   0.0 |  0.00
Modify  | 0.062471   | 0.062471   | 0.062471   |   0.0 |  0.13
Other   |            | 0.005247   |            |       |  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:       213384 ave      213384 max      213384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213384
Ave neighs/atom = 106.692
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 = 273.212415984382, Press = 4.26789078861414
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  -16004.572     -16004.572     -16072.341     -16072.341      262.27317      262.27317      36874.495      36874.495     -2350.5263     -2350.5263    
     24000  -16002.254     -16002.254     -16075.568     -16075.568      283.73182      283.73182      36804.043      36804.043      1150.7215      1150.7215    
Loop time of 46.826 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.845 ns/day, 13.007 hours/ns, 21.356 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.743     | 46.743     | 46.743     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015116   | 0.015116   | 0.015116   |   0.0 |  0.03
Output  | 3.6939e-05 | 3.6939e-05 | 3.6939e-05 |   0.0 |  0.00
Modify  | 0.062982   | 0.062982   | 0.062982   |   0.0 |  0.13
Other   |            | 0.005266   |            |       |  0.01

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

Total # of neighbors = 212390
Ave neighs/atom = 106.195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.108569717673, Press = -0.320463195752587
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  -16002.254     -16002.254     -16075.568     -16075.568      283.73182      283.73182      36804.043      36804.043      1150.7215      1150.7215    
     25000  -16004.329     -16004.329     -16075.854     -16075.854      276.81144      276.81144      36838.453      36838.453     -551.62033     -551.62033    
Loop time of 46.9153 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.842 ns/day, 13.032 hours/ns, 21.315 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.832     | 46.832     | 46.832     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01501    | 0.01501    | 0.01501    |   0.0 |  0.03
Output  | 3.723e-05  | 3.723e-05  | 3.723e-05  |   0.0 |  0.00
Modify  | 0.062457   | 0.062457   | 0.062457   |   0.0 |  0.13
Other   |            | 0.005263   |            |       |  0.01

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

Total # of neighbors = 213404
Ave neighs/atom = 106.702
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 = 273.114654888845, Press = 3.65939681723945
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  -16004.329     -16004.329     -16075.854     -16075.854      276.81144      276.81144      36838.453      36838.453     -551.62033     -551.62033    
     26000  -16005.578     -16005.578     -16074.175     -16074.175      265.47883      265.47883      36831.752      36831.752     -118.82848     -118.82848    
Loop time of 46.8576 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.844 ns/day, 13.016 hours/ns, 21.341 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.775     | 46.775     | 46.775     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015      | 0.015      | 0.015      |   0.0 |  0.03
Output  | 2.9516e-05 | 2.9516e-05 | 2.9516e-05 |   0.0 |  0.00
Modify  | 0.062788   | 0.062788   | 0.062788   |   0.0 |  0.13
Other   |            | 0.005236   |            |       |  0.01

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

Total # of neighbors = 213058
Ave neighs/atom = 106.529
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 = 273.106281510935, Press = -0.245435205670216
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  -16005.578     -16005.578     -16074.175     -16074.175      265.47883      265.47883      36831.752      36831.752     -118.82848     -118.82848    
     27000  -16002.693     -16002.693     -16074.266     -16074.266      276.99676      276.99676      36816.25       36816.25       703.77929      703.77929    
Loop time of 46.8528 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.844 ns/day, 13.015 hours/ns, 21.343 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.769     | 46.769     | 46.769     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014975   | 0.014975   | 0.014975   |   0.0 |  0.03
Output  | 4.0386e-05 | 4.0386e-05 | 4.0386e-05 |   0.0 |  0.00
Modify  | 0.063062   | 0.063062   | 0.063062   |   0.0 |  0.13
Other   |            | 0.005248   |            |       |  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:       212976 ave      212976 max      212976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212976
Ave neighs/atom = 106.488
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 = 273.182368839859, Press = 1.10338849500338
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  -16002.693     -16002.693     -16074.266     -16074.266      276.99676      276.99676      36816.25       36816.25       703.77929      703.77929    
     28000  -16006.48      -16006.48      -16073.888     -16073.888      260.87712      260.87712      36848.968      36848.968     -1079.2253     -1079.2253    
Loop time of 46.7938 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.846 ns/day, 12.998 hours/ns, 21.370 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.711     | 46.711     | 46.711     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01501    | 0.01501    | 0.01501    |   0.0 |  0.03
Output  | 3.9284e-05 | 3.9284e-05 | 3.9284e-05 |   0.0 |  0.00
Modify  | 0.06274    | 0.06274    | 0.06274    |   0.0 |  0.13
Other   |            | 0.005242   |            |       |  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:       213108 ave      213108 max      213108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213108
Ave neighs/atom = 106.554
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 = 273.261982911641, Press = 2.33305301428981
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  -16006.48      -16006.48      -16073.888     -16073.888      260.87712      260.87712      36848.968      36848.968     -1079.2253     -1079.2253    
     29000  -16002.683     -16002.683     -16074.821     -16074.821      279.17872      279.17872      36838.09       36838.09      -608.14611     -608.14611    
Loop time of 46.6383 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.556     | 46.556     | 46.556     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015032   | 0.015032   | 0.015032   |   0.0 |  0.03
Output  | 3.703e-05  | 3.703e-05  | 3.703e-05  |   0.0 |  0.00
Modify  | 0.062367   | 0.062367   | 0.062367   |   0.0 |  0.13
Other   |            | 0.005213   |            |       |  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:       212590 ave      212590 max      212590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212590
Ave neighs/atom = 106.295
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 = 273.319939588312, Press = -1.78997167129
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  -16002.683     -16002.683     -16074.821     -16074.821      279.17872      279.17872      36838.09       36838.09      -608.14611     -608.14611    
     30000  -16005.72      -16005.72      -16075.198     -16075.198      268.88913      268.88913      36811.657      36811.657      806.97779      806.97779    
Loop time of 46.6188 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.853 ns/day, 12.950 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.537     | 46.537     | 46.537     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014895   | 0.014895   | 0.014895   |   0.0 |  0.03
Output  | 3.5757e-05 | 3.5757e-05 | 3.5757e-05 |   0.0 |  0.00
Modify  | 0.062127   | 0.062127   | 0.062127   |   0.0 |  0.13
Other   |            | 0.005213   |            |       |  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:       212820 ave      212820 max      212820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212820
Ave neighs/atom = 106.41
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 = 273.38830472247, Press = 3.41653052066097
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  -16005.72      -16005.72      -16075.198     -16075.198      268.88913      268.88913      36811.657      36811.657      806.97779      806.97779    
     31000  -16006.949     -16006.949     -16077.054     -16077.054      271.31634      271.31634      36869.542      36869.542     -2501.6933     -2501.6933    
Loop time of 46.606 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.854 ns/day, 12.946 hours/ns, 21.456 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.523     | 46.523     | 46.523     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014967   | 0.014967   | 0.014967   |   0.0 |  0.03
Output  | 2.8744e-05 | 2.8744e-05 | 2.8744e-05 |   0.0 |  0.00
Modify  | 0.06263    | 0.06263    | 0.06263    |   0.0 |  0.13
Other   |            | 0.005232   |            |       |  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:       213088 ave      213088 max      213088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213088
Ave neighs/atom = 106.544
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 = 273.414507478605, Press = 1.04096758215703
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  -16006.949     -16006.949     -16077.054     -16077.054      271.31634      271.31634      36869.542      36869.542     -2501.6933     -2501.6933    
     32000  -16003.717     -16003.717     -16075.242     -16075.242      276.81064      276.81064      36807.051      36807.051      1022.2277      1022.2277    
Loop time of 46.608 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.854 ns/day, 12.947 hours/ns, 21.456 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.526     | 46.526     | 46.526     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014938   | 0.014938   | 0.014938   |   0.0 |  0.03
Output  | 4.0396e-05 | 4.0396e-05 | 4.0396e-05 |   0.0 |  0.00
Modify  | 0.061899   | 0.061899   | 0.061899   |   0.0 |  0.13
Other   |            | 0.0052     |            |       |  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:       212454 ave      212454 max      212454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212454
Ave neighs/atom = 106.227
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 = 273.367635794014, Press = 2.23569423776845
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  -16003.717     -16003.717     -16075.242     -16075.242      276.81064      276.81064      36807.051      36807.051      1022.2277      1022.2277    
     33000  -16005.809     -16005.809     -16077.082     -16077.082      275.83518      275.83518      36880.667      36880.667     -2997.3801     -2997.3801    
Loop time of 46.5518 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.856 ns/day, 12.931 hours/ns, 21.481 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.469     | 46.469     | 46.469     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01492    | 0.01492    | 0.01492    |   0.0 |  0.03
Output  | 3.6668e-05 | 3.6668e-05 | 3.6668e-05 |   0.0 |  0.00
Modify  | 0.062375   | 0.062375   | 0.062375   |   0.0 |  0.13
Other   |            | 0.005205   |            |       |  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:       213130 ave      213130 max      213130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213130
Ave neighs/atom = 106.565
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 = 273.300897964764, Press = -0.289684789806458
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  -16005.809     -16005.809     -16077.082     -16077.082      275.83518      275.83518      36880.667      36880.667     -2997.3801     -2997.3801    
     34000  -16005.124     -16005.124     -16073.867     -16073.867      266.04367      266.04367      36787.259      36787.259      2214.0292      2214.0292    
Loop time of 46.5414 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.856 ns/day, 12.928 hours/ns, 21.486 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.458     | 46.458     | 46.458     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014931   | 0.014931   | 0.014931   |   0.0 |  0.03
Output  | 3.5917e-05 | 3.5917e-05 | 3.5917e-05 |   0.0 |  0.00
Modify  | 0.062727   | 0.062727   | 0.062727   |   0.0 |  0.13
Other   |            | 0.005239   |            |       |  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:       212454 ave      212454 max      212454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212454
Ave neighs/atom = 106.227
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 = 273.3280515937, Press = 1.3579501029693
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  -16005.124     -16005.124     -16073.867     -16073.867      266.04367      266.04367      36787.259      36787.259      2214.0292      2214.0292    
     35000  -16004.311     -16004.311     -16072.106     -16072.106      262.37348      262.37348      36874.639      36874.639     -2230.7182     -2230.7182    
Loop time of 46.6596 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.852 ns/day, 12.961 hours/ns, 21.432 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.577     | 46.577     | 46.577     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014946   | 0.014946   | 0.014946   |   0.0 |  0.03
Output  | 3.0036e-05 | 3.0036e-05 | 3.0036e-05 |   0.0 |  0.00
Modify  | 0.062454   | 0.062454   | 0.062454   |   0.0 |  0.13
Other   |            | 0.005216   |            |       |  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:       213262 ave      213262 max      213262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213262
Ave neighs/atom = 106.631
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 = 273.306110000649, Press = 0.556067279849745
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  -16004.311     -16004.311     -16072.106     -16072.106      262.37348      262.37348      36874.639      36874.639     -2230.7182     -2230.7182    
     36000  -16005.568     -16005.568     -16074.389     -16074.389      266.34531      266.34531      36807.843      36807.843      1095.2316      1095.2316    
Loop time of 46.6327 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.853 ns/day, 12.954 hours/ns, 21.444 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.55      | 46.55      | 46.55      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014946   | 0.014946   | 0.014946   |   0.0 |  0.03
Output  | 4.0626e-05 | 4.0626e-05 | 4.0626e-05 |   0.0 |  0.00
Modify  | 0.062252   | 0.062252   | 0.062252   |   0.0 |  0.13
Other   |            | 0.005217   |            |       |  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:       212074 ave      212074 max      212074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212074
Ave neighs/atom = 106.037
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 = 273.302723277267, Press = 1.26804274999461
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  -16005.568     -16005.568     -16074.389     -16074.389      266.34531      266.34531      36807.843      36807.843      1095.2316      1095.2316    
     37000  -16003.544     -16003.544     -16076.098     -16076.098      280.79197      280.79197      36843.899      36843.899     -1001.5709     -1001.5709    
Loop time of 46.9394 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.841 ns/day, 13.039 hours/ns, 21.304 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.856     | 46.856     | 46.856     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014987   | 0.014987   | 0.014987   |   0.0 |  0.03
Output  | 4.0516e-05 | 4.0516e-05 | 4.0516e-05 |   0.0 |  0.00
Modify  | 0.062763   | 0.062763   | 0.062763   |   0.0 |  0.13
Other   |            | 0.005257   |            |       |  0.01

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

Total # of neighbors = 213168
Ave neighs/atom = 106.584
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 = 273.257873381289, Press = -0.611497104831437
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  -16003.544     -16003.544     -16076.098     -16076.098      280.79197      280.79197      36843.899      36843.899     -1001.5709     -1001.5709    
     38000  -16006.436     -16006.436     -16077.535     -16077.535      275.16062      275.16062      36820.236      36820.236      136.65208      136.65208    
Loop time of 47.0166 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.838 ns/day, 13.060 hours/ns, 21.269 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.934     | 46.934     | 46.934     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015034   | 0.015034   | 0.015034   |   0.0 |  0.03
Output  | 3.6468e-05 | 3.6468e-05 | 3.6468e-05 |   0.0 |  0.00
Modify  | 0.062663   | 0.062663   | 0.062663   |   0.0 |  0.13
Other   |            | 0.005246   |            |       |  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:       213030 ave      213030 max      213030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213030
Ave neighs/atom = 106.515
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 = 273.219625186312, Press = 2.61550016765616
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  -16006.436     -16006.436     -16077.535     -16077.535      275.16062      275.16062      36820.236      36820.236      136.65208      136.65208    
     39000  -16004.705     -16004.705     -16075.857     -16075.857      275.3669       275.3669       36845.549      36845.549     -991.73026     -991.73026    
Loop time of 46.8337 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.845 ns/day, 13.009 hours/ns, 21.352 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.751     | 46.751     | 46.751     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014996   | 0.014996   | 0.014996   |   0.0 |  0.03
Output  | 3.5296e-05 | 3.5296e-05 | 3.5296e-05 |   0.0 |  0.00
Modify  | 0.062618   | 0.062618   | 0.062618   |   0.0 |  0.13
Other   |            | 0.005263   |            |       |  0.01

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

Total # of neighbors = 213228
Ave neighs/atom = 106.614
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 = 273.230869336565, Press = -0.793421485133038
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  -16004.705     -16004.705     -16075.857     -16075.857      275.3669       275.3669       36845.549      36845.549     -991.73026     -991.73026    
     40000  -16006.242     -16006.242     -16076.271     -16076.271      271.02114      271.02114      36781.006      36781.006      2322.1519      2322.1519    
Loop time of 46.8616 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.844 ns/day, 13.017 hours/ns, 21.339 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.778     | 46.778     | 46.778     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015016   | 0.015016   | 0.015016   |   0.0 |  0.03
Output  | 2.9185e-05 | 2.9185e-05 | 2.9185e-05 |   0.0 |  0.00
Modify  | 0.063079   | 0.063079   | 0.063079   |   0.0 |  0.13
Other   |            | 0.005249   |            |       |  0.01

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

Total # of neighbors = 212974
Ave neighs/atom = 106.487
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 = 273.155549541618, Press = 1.79703578883477
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  -16006.242     -16006.242     -16076.271     -16076.271      271.02114      271.02114      36781.006      36781.006      2322.1519      2322.1519    
     41000  -16002.634     -16002.634     -16074.208     -16074.208      277.0008       277.0008       36856.958      36856.958     -1392.6494     -1392.6494    
Loop time of 46.9533 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.840 ns/day, 13.043 hours/ns, 21.298 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.87      | 46.87      | 46.87      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015012   | 0.015012   | 0.015012   |   0.0 |  0.03
Output  | 3.8322e-05 | 3.8322e-05 | 3.8322e-05 |   0.0 |  0.00
Modify  | 0.062871   | 0.062871   | 0.062871   |   0.0 |  0.13
Other   |            | 0.005264   |            |       |  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:       213814 ave      213814 max      213814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213814
Ave neighs/atom = 106.907
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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
36826.7067878413

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0