# 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.0000000 0.0000000 0.0000000) 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.0000000 0.0000000 0.0000000) to (33.234407 33.234407 33.234407)
  create_atoms CPU = 0.002 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_001
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_001#item-citation

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

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 247.765 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.349 ns/day, 68.824 hours/ns, 4.036 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 247.21     | 247.21     | 247.21     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10229    | 0.10229    | 0.10229    |   0.0 |  0.04
Output  | 0.00023089 | 0.00023089 | 0.00023089 |   0.0 |  0.00
Modify  | 0.39016    | 0.39016    | 0.39016    |   0.0 |  0.16
Other   |            | 0.06387    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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
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 232.919 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.371 ns/day, 64.700 hours/ns, 4.293 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.42     | 232.42     | 232.42     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093524   | 0.093524   | 0.093524   |   0.0 |  0.04
Output  | 0.00022523 | 0.00022523 | 0.00022523 |   0.0 |  0.00
Modify  | 0.34288    | 0.34288    | 0.34288    |   0.0 |  0.15
Other   |            | 0.06134    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213126.0 ave      213126 max      213126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213126
Ave neighs/atom = 106.56300
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
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 229.426 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.729 hours/ns, 4.359 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.94     | 228.94     | 228.94     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092878   | 0.092878   | 0.092878   |   0.0 |  0.04
Output  | 0.00018602 | 0.00018602 | 0.00018602 |   0.0 |  0.00
Modify  | 0.33514    | 0.33514    | 0.33514    |   0.0 |  0.15
Other   |            | 0.06025    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212620.0 ave      212620 max      212620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212620
Ave neighs/atom = 106.31000
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
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 229.163 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.656 hours/ns, 4.364 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.68     | 228.68     | 228.68     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092289   | 0.092289   | 0.092289   |   0.0 |  0.04
Output  | 0.00018761 | 0.00018761 | 0.00018761 |   0.0 |  0.00
Modify  | 0.33386    | 0.33386    | 0.33386    |   0.0 |  0.15
Other   |            | 0.06055    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213270.0 ave      213270 max      213270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213270
Ave neighs/atom = 106.63500
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
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 228.999 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.611 hours/ns, 4.367 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.51     | 228.51     | 228.51     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092284   | 0.092284   | 0.092284   |   0.0 |  0.04
Output  | 0.00015446 | 0.00015446 | 0.00015446 |   0.0 |  0.00
Modify  | 0.33543    | 0.33543    | 0.33543    |   0.0 |  0.15
Other   |            | 0.06075    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213250.0 ave      213250 max      213250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213250
Ave neighs/atom = 106.62500
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
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 228.534 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.482 hours/ns, 4.376 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.03     | 228.03     | 228.03     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091487   | 0.091487   | 0.091487   |   0.0 |  0.04
Output  | 0.00022237 | 0.00022237 | 0.00022237 |   0.0 |  0.00
Modify  | 0.34742    | 0.34742    | 0.34742    |   0.0 |  0.15
Other   |            | 0.06069    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213022.0 ave      213022 max      213022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213022
Ave neighs/atom = 106.51100
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
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 229.022 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.617 hours/ns, 4.366 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.52     | 228.52     | 228.52     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092267   | 0.092267   | 0.092267   |   0.0 |  0.04
Output  | 0.00015388 | 0.00015388 | 0.00015388 |   0.0 |  0.00
Modify  | 0.34946    | 0.34946    | 0.34946    |   0.0 |  0.15
Other   |            | 0.06095    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213272.0 ave      213272 max      213272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213272
Ave neighs/atom = 106.63600
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
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 228.465 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.462 hours/ns, 4.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.96     | 227.96     | 227.96     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092234   | 0.092234   | 0.092234   |   0.0 |  0.04
Output  | 0.00015383 | 0.00015383 | 0.00015383 |   0.0 |  0.00
Modify  | 0.3483     | 0.3483     | 0.3483     |   0.0 |  0.15
Other   |            | 0.06039    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212506.0 ave      212506 max      212506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212506
Ave neighs/atom = 106.25300
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
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 228.61 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.503 hours/ns, 4.374 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.11     | 228.11     | 228.11     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092051   | 0.092051   | 0.092051   |   0.0 |  0.04
Output  | 0.0001544  | 0.0001544  | 0.0001544  |   0.0 |  0.00
Modify  | 0.34823    | 0.34823    | 0.34823    |   0.0 |  0.15
Other   |            | 0.06077    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213512.0 ave      213512 max      213512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213512
Ave neighs/atom = 106.75600
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
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 228.45 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.458 hours/ns, 4.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.95     | 227.95     | 227.95     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091969   | 0.091969   | 0.091969   |   0.0 |  0.04
Output  | 0.00015258 | 0.00015258 | 0.00015258 |   0.0 |  0.00
Modify  | 0.34887    | 0.34887    | 0.34887    |   0.0 |  0.15
Other   |            | 0.06049    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212920.0 ave      212920 max      212920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212920
Ave neighs/atom = 106.46000
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
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 228.697 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.527 hours/ns, 4.373 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.19     | 228.19     | 228.19     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092419   | 0.092419   | 0.092419   |   0.0 |  0.04
Output  | 0.00015427 | 0.00015427 | 0.00015427 |   0.0 |  0.00
Modify  | 0.34882    | 0.34882    | 0.34882    |   0.0 |  0.15
Other   |            | 0.06049    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213834.0 ave      213834 max      213834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213834
Ave neighs/atom = 106.91700
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
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 228.583 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.495 hours/ns, 4.375 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.08     | 228.08     | 228.08     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09242    | 0.09242    | 0.09242    |   0.0 |  0.04
Output  | 0.00019654 | 0.00019654 | 0.00019654 |   0.0 |  0.00
Modify  | 0.34949    | 0.34949    | 0.34949    |   0.0 |  0.15
Other   |            | 0.05988    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213400.0 ave      213400 max      213400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213400
Ave neighs/atom = 106.70000
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
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 228.566 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.491 hours/ns, 4.375 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.06     | 228.06     | 228.06     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092431   | 0.092431   | 0.092431   |   0.0 |  0.04
Output  | 0.00015407 | 0.00015407 | 0.00015407 |   0.0 |  0.00
Modify  | 0.34854    | 0.34854    | 0.34854    |   0.0 |  0.15
Other   |            | 0.06076    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213434.0 ave      213434 max      213434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213434
Ave neighs/atom = 106.71700
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
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 228.702 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.528 hours/ns, 4.372 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.2      | 228.2      | 228.2      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091964   | 0.091964   | 0.091964   |   0.0 |  0.04
Output  | 0.00015338 | 0.00015338 | 0.00015338 |   0.0 |  0.00
Modify  | 0.34923    | 0.34923    | 0.34923    |   0.0 |  0.15
Other   |            | 0.06079    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212658.0 ave      212658 max      212658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212658
Ave neighs/atom = 106.32900
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
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 228.491 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.470 hours/ns, 4.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.99     | 227.99     | 227.99     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092773   | 0.092773   | 0.092773   |   0.0 |  0.04
Output  | 0.00042976 | 0.00042976 | 0.00042976 |   0.0 |  0.00
Modify  | 0.34795    | 0.34795    | 0.34795    |   0.0 |  0.15
Other   |            | 0.0601     |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212464.0 ave      212464 max      212464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212464
Ave neighs/atom = 106.23200
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
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 228.578 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.494 hours/ns, 4.375 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.08     | 228.08     | 228.08     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092429   | 0.092429   | 0.092429   |   0.0 |  0.04
Output  | 0.00015452 | 0.00015452 | 0.00015452 |   0.0 |  0.00
Modify  | 0.34809    | 0.34809    | 0.34809    |   0.0 |  0.15
Other   |            | 0.06062    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213728.0 ave      213728 max      213728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213728
Ave neighs/atom = 106.86400
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
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 228.677 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.521 hours/ns, 4.373 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.18     | 228.18     | 228.18     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091538   | 0.091538   | 0.091538   |   0.0 |  0.04
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.34848    | 0.34848    | 0.34848    |   0.0 |  0.15
Other   |            | 0.06006    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212898.0 ave      212898 max      212898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212898
Ave neighs/atom = 106.44900
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
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 229.008 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.613 hours/ns, 4.367 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.5      | 228.5      | 228.5      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093566   | 0.093566   | 0.093566   |   0.0 |  0.04
Output  | 0.00020947 | 0.00020947 | 0.00020947 |   0.0 |  0.00
Modify  | 0.35103    | 0.35103    | 0.35103    |   0.0 |  0.15
Other   |            | 0.05974    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212672.0 ave      212672 max      212672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212672
Ave neighs/atom = 106.33600
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
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 229.365 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.713 hours/ns, 4.360 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.86     | 228.86     | 228.86     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093502   | 0.093502   | 0.093502   |   0.0 |  0.04
Output  | 0.00015595 | 0.00015595 | 0.00015595 |   0.0 |  0.00
Modify  | 0.35145    | 0.35145    | 0.35145    |   0.0 |  0.15
Other   |            | 0.0595     |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213230.0 ave      213230 max      213230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213230
Ave neighs/atom = 106.61500
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
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 229.335 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.704 hours/ns, 4.360 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.83     | 228.83     | 228.83     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094089   | 0.094089   | 0.094089   |   0.0 |  0.04
Output  | 0.00015617 | 0.00015617 | 0.00015617 |   0.0 |  0.00
Modify  | 0.35135    | 0.35135    | 0.35135    |   0.0 |  0.15
Other   |            | 0.05927    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213714.0 ave      213714 max      213714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213714
Ave neighs/atom = 106.85700
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
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 254.267 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.340 ns/day, 70.630 hours/ns, 3.933 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 253.67     | 253.67     | 253.67     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10349    | 0.10349    | 0.10349    |   0.0 |  0.04
Output  | 0.00015308 | 0.00015308 | 0.00015308 |   0.0 |  0.00
Modify  | 0.42406    | 0.42406    | 0.42406    |   0.0 |  0.17
Other   |            | 0.06603    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213084.0 ave      213084 max      213084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213084
Ave neighs/atom = 106.54200
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
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 260.696 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.415 hours/ns, 3.836 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.08     | 260.08     | 260.08     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10584    | 0.10584    | 0.10584    |   0.0 |  0.04
Output  | 0.00018964 | 0.00018964 | 0.00018964 |   0.0 |  0.00
Modify  | 0.44082    | 0.44082    | 0.44082    |   0.0 |  0.17
Other   |            | 0.06684    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213052.0 ave      213052 max      213052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213052
Ave neighs/atom = 106.52600
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
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 260.415 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.332 ns/day, 72.338 hours/ns, 3.840 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 259.8      | 259.8      | 259.8      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10604    | 0.10604    | 0.10604    |   0.0 |  0.04
Output  | 0.00015389 | 0.00015389 | 0.00015389 |   0.0 |  0.00
Modify  | 0.44072    | 0.44072    | 0.44072    |   0.0 |  0.17
Other   |            | 0.06687    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213384.0 ave      213384 max      213384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213384
Ave neighs/atom = 106.69200
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
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 260.538 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.332 ns/day, 72.372 hours/ns, 3.838 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 259.92     | 259.92     | 259.92     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10488    | 0.10488    | 0.10488    |   0.0 |  0.04
Output  | 0.00019415 | 0.00019415 | 0.00019415 |   0.0 |  0.00
Modify  | 0.44189    | 0.44189    | 0.44189    |   0.0 |  0.17
Other   |            | 0.06728    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212390.0 ave      212390 max      212390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212390
Ave neighs/atom = 106.19500
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
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 260.832 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.453 hours/ns, 3.834 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.22     | 260.22     | 260.22     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10601    | 0.10601    | 0.10601    |   0.0 |  0.04
Output  | 0.00015512 | 0.00015512 | 0.00015512 |   0.0 |  0.00
Modify  | 0.44006    | 0.44006    | 0.44006    |   0.0 |  0.17
Other   |            | 0.06661    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213404.0 ave      213404 max      213404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213404
Ave neighs/atom = 106.70200
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
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 260.74 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.428 hours/ns, 3.835 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.12     | 260.12     | 260.12     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10526    | 0.10526    | 0.10526    |   0.0 |  0.04
Output  | 0.00015256 | 0.00015256 | 0.00015256 |   0.0 |  0.00
Modify  | 0.44444    | 0.44444    | 0.44444    |   0.0 |  0.17
Other   |            | 0.06795    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213058.0 ave      213058 max      213058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213058
Ave neighs/atom = 106.52900
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
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 261.181 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.550 hours/ns, 3.829 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    | 260.56     | 260.56     | 260.56     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10645    | 0.10645    | 0.10645    |   0.0 |  0.04
Output  | 0.00019819 | 0.00019819 | 0.00019819 |   0.0 |  0.00
Modify  | 0.4432     | 0.4432     | 0.4432     |   0.0 |  0.17
Other   |            | 0.06733    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212976.0 ave      212976 max      212976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212976
Ave neighs/atom = 106.48800
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
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 259.223 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.333 ns/day, 72.006 hours/ns, 3.858 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 258.62     | 258.62     | 258.62     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10534    | 0.10534    | 0.10534    |   0.0 |  0.04
Output  | 0.00015293 | 0.00015293 | 0.00015293 |   0.0 |  0.00
Modify  | 0.43614    | 0.43614    | 0.43614    |   0.0 |  0.17
Other   |            | 0.06568    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213108.0 ave      213108 max      213108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213108
Ave neighs/atom = 106.55400
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
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 229.111 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.642 hours/ns, 4.365 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.61     | 228.61     | 228.61     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0932     | 0.0932     | 0.0932     |   0.0 |  0.04
Output  | 0.00015634 | 0.00015634 | 0.00015634 |   0.0 |  0.00
Modify  | 0.35017    | 0.35017    | 0.35017    |   0.0 |  0.15
Other   |            | 0.06155    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212590.0 ave      212590 max      212590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212590
Ave neighs/atom = 106.29500
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
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 229.969 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.880 hours/ns, 4.348 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.46     | 229.46     | 229.46     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092554   | 0.092554   | 0.092554   |   0.0 |  0.04
Output  | 0.00015483 | 0.00015483 | 0.00015483 |   0.0 |  0.00
Modify  | 0.35375    | 0.35375    | 0.35375    |   0.0 |  0.15
Other   |            | 0.06017    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212820.0 ave      212820 max      212820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212820
Ave neighs/atom = 106.41000
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
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 228.87 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.575 hours/ns, 4.369 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.37     | 228.37     | 228.37     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093192   | 0.093192   | 0.093192   |   0.0 |  0.04
Output  | 0.00015846 | 0.00015846 | 0.00015846 |   0.0 |  0.00
Modify  | 0.34901    | 0.34901    | 0.34901    |   0.0 |  0.15
Other   |            | 0.06016    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213088.0 ave      213088 max      213088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213088
Ave neighs/atom = 106.54400
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
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 229.075 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.632 hours/ns, 4.365 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.57     | 228.57     | 228.57     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091841   | 0.091841   | 0.091841   |   0.0 |  0.04
Output  | 0.00015747 | 0.00015747 | 0.00015747 |   0.0 |  0.00
Modify  | 0.35036    | 0.35036    | 0.35036    |   0.0 |  0.15
Other   |            | 0.06056    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212454.0 ave      212454 max      212454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212454
Ave neighs/atom = 106.22700
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
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 229.155 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.654 hours/ns, 4.364 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.65     | 228.65     | 228.65     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093241   | 0.093241   | 0.093241   |   0.0 |  0.04
Output  | 0.00015616 | 0.00015616 | 0.00015616 |   0.0 |  0.00
Modify  | 0.35216    | 0.35216    | 0.35216    |   0.0 |  0.15
Other   |            | 0.06076    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213130.0 ave      213130 max      213130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213130
Ave neighs/atom = 106.56500
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
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 240.857 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.359 ns/day, 66.905 hours/ns, 4.152 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 240.31     | 240.31     | 240.31     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097865   | 0.097865   | 0.097865   |   0.0 |  0.04
Output  | 0.00015585 | 0.00015585 | 0.00015585 |   0.0 |  0.00
Modify  | 0.38479    | 0.38479    | 0.38479    |   0.0 |  0.16
Other   |            | 0.0627     |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212454.0 ave      212454 max      212454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212454
Ave neighs/atom = 106.22700
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
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 260.807 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.446 hours/ns, 3.834 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.19     | 260.19     | 260.19     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10545    | 0.10545    | 0.10545    |   0.0 |  0.04
Output  | 0.00015493 | 0.00015493 | 0.00015493 |   0.0 |  0.00
Modify  | 0.44369    | 0.44369    | 0.44369    |   0.0 |  0.17
Other   |            | 0.06737    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213262.0 ave      213262 max      213262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213262
Ave neighs/atom = 106.63100
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
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 260.674 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.410 hours/ns, 3.836 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.06     | 260.06     | 260.06     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10611    | 0.10611    | 0.10611    |   0.0 |  0.04
Output  | 0.00022888 | 0.00022888 | 0.00022888 |   0.0 |  0.00
Modify  | 0.44186    | 0.44186    | 0.44186    |   0.0 |  0.17
Other   |            | 0.0669     |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212074.0 ave      212074 max      212074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212074
Ave neighs/atom = 106.03700
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
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 260.568 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.332 ns/day, 72.380 hours/ns, 3.838 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 259.96     | 259.96     | 259.96     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10577    | 0.10577    | 0.10577    |   0.0 |  0.04
Output  | 0.000192   | 0.000192   | 0.000192   |   0.0 |  0.00
Modify  | 0.43881    | 0.43881    | 0.43881    |   0.0 |  0.17
Other   |            | 0.06615    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213168.0 ave      213168 max      213168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213168
Ave neighs/atom = 106.58400
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
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 260.868 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.463 hours/ns, 3.833 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.26     | 260.26     | 260.26     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.105      | 0.105      | 0.105      |   0.0 |  0.04
Output  | 0.00015471 | 0.00015471 | 0.00015471 |   0.0 |  0.00
Modify  | 0.43931    | 0.43931    | 0.43931    |   0.0 |  0.17
Other   |            | 0.06696    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213030.0 ave      213030 max      213030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213030
Ave neighs/atom = 106.51500
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
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 228.856 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.571 hours/ns, 4.370 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.35     | 228.35     | 228.35     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093578   | 0.093578   | 0.093578   |   0.0 |  0.04
Output  | 0.00015363 | 0.00015363 | 0.00015363 |   0.0 |  0.00
Modify  | 0.35243    | 0.35243    | 0.35243    |   0.0 |  0.15
Other   |            | 0.06041    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213228.0 ave      213228 max      213228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213228
Ave neighs/atom = 106.61400
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
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 228.839 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.566 hours/ns, 4.370 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.33     | 228.33     | 228.33     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093398   | 0.093398   | 0.093398   |   0.0 |  0.04
Output  | 0.00015638 | 0.00015638 | 0.00015638 |   0.0 |  0.00
Modify  | 0.35142    | 0.35142    | 0.35142    |   0.0 |  0.15
Other   |            | 0.06042    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212974.0 ave      212974 max      212974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212974
Ave neighs/atom = 106.48700
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
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 228.886 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.580 hours/ns, 4.369 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.38     | 228.38     | 228.38     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094228   | 0.094228   | 0.094228   |   0.0 |  0.04
Output  | 0.00015649 | 0.00015649 | 0.00015649 |   0.0 |  0.00
Modify  | 0.3516     | 0.3516     | 0.3516     |   0.0 |  0.15
Other   |            | 0.06047    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213814.0 ave      213814 max      213814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213814
Ave neighs/atom = 106.90700
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