# 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.004 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 313.15*${_u_temperature}
variable temp_converted equal 313.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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   -16066.005   -16066.005    -16146.92    -16146.92       313.15       313.15    36708.262    36708.262    2354.4198    2354.4198 
    1000   -15981.273   -15981.273   -16062.964   -16062.964    316.15331    316.15331     36860.71     36860.71    37.776688    37.776688 
Loop time of 233.02 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.371 ns/day, 64.728 hours/ns, 4.291 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.51     | 232.51     | 232.51     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097326   | 0.097326   | 0.097326   |   0.0 |  0.04
Output  | 0.00019014 | 0.00019014 | 0.00019014 |   0.0 |  0.00
Modify  | 0.34811    | 0.34811    | 0.34811    |   0.0 |  0.15
Other   |            | 0.06092    |            |       |  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   -15981.273   -15981.273   -16062.964   -16062.964    316.15331    316.15331     36860.71     36860.71    37.776688    37.776688 
    2000   -15982.363   -15982.363     -16063.8     -16063.8    315.17095    315.17095    36864.864    36864.864   -354.58073   -354.58073 
Loop time of 228.308 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.419 hours/ns, 4.380 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.82     | 227.82     | 227.82     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093323   | 0.093323   | 0.093323   |   0.0 |  0.04
Output  | 0.00018723 | 0.00018723 | 0.00018723 |   0.0 |  0.00
Modify  | 0.33174    | 0.33174    | 0.33174    |   0.0 |  0.15
Other   |            | 0.06026    |            |       |  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:      211994.0 ave      211994 max      211994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211994
Ave neighs/atom = 105.99700
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   -15982.363   -15982.363     -16063.8     -16063.8    315.17095    315.17095    36864.864    36864.864   -354.58073   -354.58073 
    3000   -15983.323   -15983.323   -16067.208   -16067.208    324.64377    324.64377    36819.196    36819.196    1622.0508    1622.0508 
Loop time of 228.4 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.444 hours/ns, 4.378 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.91     | 227.91     | 227.91     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093085   | 0.093085   | 0.093085   |   0.0 |  0.04
Output  | 0.00022683 | 0.00022683 | 0.00022683 |   0.0 |  0.00
Modify  | 0.33129    | 0.33129    | 0.33129    |   0.0 |  0.15
Other   |            | 0.06089    |            |       |  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:      211962.0 ave      211962 max      211962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211962
Ave neighs/atom = 105.98100
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   -15983.323   -15983.323   -16067.208   -16067.208    324.64377    324.64377    36819.196    36819.196    1622.0508    1622.0508 
    4000   -15986.303   -15986.303   -16068.643   -16068.643    318.66471    318.66471    36799.956    36799.956    2253.3661    2253.3661 
Loop time of 228.546 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.485 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.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093654   | 0.093654   | 0.093654   |   0.0 |  0.04
Output  | 0.00018684 | 0.00018684 | 0.00018684 |   0.0 |  0.00
Modify  | 0.33178    | 0.33178    | 0.33178    |   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:      212400.0 ave      212400 max      212400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212400
Ave neighs/atom = 106.20000
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   -15986.303   -15986.303   -16068.643   -16068.643    318.66471    318.66471    36799.956    36799.956    2253.3661    2253.3661 
    5000   -15981.876   -15981.876   -16067.899   -16067.899    332.91707    332.91707    36820.391    36820.391    1681.6956    1681.6956 
Loop time of 228.533 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.481 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.05     | 228.05     | 228.05     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09308    | 0.09308    | 0.09308    |   0.0 |  0.04
Output  | 0.00015361 | 0.00015361 | 0.00015361 |   0.0 |  0.00
Modify  | 0.33328    | 0.33328    | 0.33328    |   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:      212410.0 ave      212410 max      212410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212410
Ave neighs/atom = 106.20500
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 = 307.165648124887, Press = -845.795356476634
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   -15981.876   -15981.876   -16067.899   -16067.899    332.91707    332.91707    36820.391    36820.391    1681.6956    1681.6956 
    6000   -15983.938   -15983.938   -16071.506   -16071.506    338.89502    338.89502    36855.461    36855.461   -663.55807   -663.55807 
Loop time of 228.246 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.402 hours/ns, 4.381 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.74     | 227.74     | 227.74     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09365    | 0.09365    | 0.09365    |   0.0 |  0.04
Output  | 0.00015334 | 0.00015334 | 0.00015334 |   0.0 |  0.00
Modify  | 0.34821    | 0.34821    | 0.34821    |   0.0 |  0.15
Other   |            | 0.06012    |            |       |  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:      212552.0 ave      212552 max      212552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212552
Ave neighs/atom = 106.27600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.44501544538, Press = -69.9618662398861
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   -15983.938   -15983.938   -16071.506   -16071.506    338.89502    338.89502    36855.461    36855.461   -663.55807   -663.55807 
    7000    -15987.61    -15987.61   -16062.364   -16062.364    289.30573    289.30573    36862.049    36862.049   -320.70548   -320.70548 
Loop time of 228.545 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.485 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.04     | 228.04     | 228.04     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093569   | 0.093569   | 0.093569   |   0.0 |  0.04
Output  | 0.00015259 | 0.00015259 | 0.00015259 |   0.0 |  0.00
Modify  | 0.34747    | 0.34747    | 0.34747    |   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:      212300.0 ave      212300 max      212300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212300
Ave neighs/atom = 106.15000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.862732748602, Press = 2.21329826274468
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    -15987.61    -15987.61   -16062.364   -16062.364    289.30573    289.30573    36862.049    36862.049   -320.70548   -320.70548 
    8000   -15982.703   -15982.703    -16068.16    -16068.16    330.72738    330.72738    36871.155    36871.155   -1067.8107   -1067.8107 
Loop time of 228.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.398 hours/ns, 4.381 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.73     | 227.73     | 227.73     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094013   | 0.094013   | 0.094013   |   0.0 |  0.04
Output  | 0.00015464 | 0.00015464 | 0.00015464 |   0.0 |  0.00
Modify  | 0.34647    | 0.34647    | 0.34647    |   0.0 |  0.15
Other   |            | 0.06065    |            |       |  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:      211500.0 ave      211500 max      211500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211500
Ave neighs/atom = 105.75000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.659573807431, Press = -14.4735496398916
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   -15982.703   -15982.703    -16068.16    -16068.16    330.72738    330.72738    36871.155    36871.155   -1067.8107   -1067.8107 
    9000   -15984.502   -15984.502    -16065.41    -16065.41    313.12563    313.12563    36822.426    36822.426    1497.5398    1497.5398 
Loop time of 228.224 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.395 hours/ns, 4.382 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.72     | 227.72     | 227.72     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093112   | 0.093112   | 0.093112   |   0.0 |  0.04
Output  | 0.00015387 | 0.00015387 | 0.00015387 |   0.0 |  0.00
Modify  | 0.34718    | 0.34718    | 0.34718    |   0.0 |  0.15
Other   |            | 0.06028    |            |       |  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:      212022.0 ave      212022 max      212022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212022
Ave neighs/atom = 106.01100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.756384066986, Press = -14.3195719645354
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   -15984.502   -15984.502    -16065.41    -16065.41    313.12563    313.12563    36822.426    36822.426    1497.5398    1497.5398 
   10000     -15983.4     -15983.4   -16065.083   -16065.083     316.1201     316.1201    36888.212    36888.212   -1876.3404   -1876.3404 
Loop time of 228.364 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.434 hours/ns, 4.379 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.86     | 227.86     | 227.86     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093913   | 0.093913   | 0.093913   |   0.0 |  0.04
Output  | 0.00015398 | 0.00015398 | 0.00015398 |   0.0 |  0.00
Modify  | 0.34681    | 0.34681    | 0.34681    |   0.0 |  0.15
Other   |            | 0.06015    |            |       |  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:      212456.0 ave      212456 max      212456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212456
Ave neighs/atom = 106.22800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.305985266258, Press = -5.53264130892726
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     -15983.4     -15983.4   -16065.083   -16065.083     316.1201     316.1201    36888.212    36888.212   -1876.3404   -1876.3404 
   11000   -15984.004   -15984.004   -16063.858   -16063.858    309.04426    309.04426    36841.049    36841.049    688.84256    688.84256 
Loop time of 228.295 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.415 hours/ns, 4.380 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.79     | 227.79     | 227.79     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093613   | 0.093613   | 0.093613   |   0.0 |  0.04
Output  | 0.00015177 | 0.00015177 | 0.00015177 |   0.0 |  0.00
Modify  | 0.34696    | 0.34696    | 0.34696    |   0.0 |  0.15
Other   |            | 0.06104    |            |       |  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:      211658.0 ave      211658 max      211658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211658
Ave neighs/atom = 105.82900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.643666736932, Press = 4.3400454515702
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   -15984.004   -15984.004   -16063.858   -16063.858    309.04426    309.04426    36841.049    36841.049    688.84256    688.84256 
   12000   -15980.053   -15980.053   -16062.662   -16062.662    319.70347    319.70347    36840.956    36840.956    1001.5784    1001.5784 
Loop time of 228.185 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.385 hours/ns, 4.382 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.68     | 227.68     | 227.68     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093451   | 0.093451   | 0.093451   |   0.0 |  0.04
Output  | 0.00015315 | 0.00015315 | 0.00015315 |   0.0 |  0.00
Modify  | 0.34719    | 0.34719    | 0.34719    |   0.0 |  0.15
Other   |            | 0.06021    |            |       |  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:      212328.0 ave      212328 max      212328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212328
Ave neighs/atom = 106.16400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.572185422258, Press = -3.54749133324013
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   -15980.053   -15980.053   -16062.662   -16062.662    319.70347    319.70347    36840.956    36840.956    1001.5784    1001.5784 
   13000   -15981.611   -15981.611   -16065.835   -16065.835    325.95474    325.95474    36861.904    36861.904    -450.9441    -450.9441 
Loop time of 228.118 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.366 hours/ns, 4.384 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.62     | 227.62     | 227.62     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093196   | 0.093196   | 0.093196   |   0.0 |  0.04
Output  | 0.00015254 | 0.00015254 | 0.00015254 |   0.0 |  0.00
Modify  | 0.34788    | 0.34788    | 0.34788    |   0.0 |  0.15
Other   |            | 0.06024    |            |       |  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:      211956.0 ave      211956 max      211956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211956
Ave neighs/atom = 105.97800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.19388814301, Press = 0.691127542962787
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   -15981.611   -15981.611   -16065.835   -16065.835    325.95474    325.95474    36861.904    36861.904    -450.9441    -450.9441 
   14000   -15983.389   -15983.389   -16063.438   -16063.438    309.79589    309.79589    36822.221    36822.221    1961.6976    1961.6976 
Loop time of 228.31 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.420 hours/ns, 4.380 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.81     | 227.81     | 227.81     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093461   | 0.093461   | 0.093461   |   0.0 |  0.04
Output  | 0.00015179 | 0.00015179 | 0.00015179 |   0.0 |  0.00
Modify  | 0.34701    | 0.34701    | 0.34701    |   0.0 |  0.15
Other   |            | 0.06101    |            |       |  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:      211840.0 ave      211840 max      211840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211840
Ave neighs/atom = 105.92000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.345986795971, Press = 4.71480775330047
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   -15983.389   -15983.389   -16063.438   -16063.438    309.79589    309.79589    36822.221    36822.221    1961.6976    1961.6976 
   15000   -15987.896   -15987.896   -16070.506   -16070.506    319.70809    319.70809    36830.281    36830.281     854.1206     854.1206 
Loop time of 228.024 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.340 hours/ns, 4.385 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.52     | 227.52     | 227.52     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09302    | 0.09302    | 0.09302    |   0.0 |  0.04
Output  | 0.00047081 | 0.00047081 | 0.00047081 |   0.0 |  0.00
Modify  | 0.34704    | 0.34704    | 0.34704    |   0.0 |  0.15
Other   |            | 0.06057    |            |       |  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:      212532.0 ave      212532 max      212532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212532
Ave neighs/atom = 106.26600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.097783122648, Press = -4.27432155759751
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   -15987.896   -15987.896   -16070.506   -16070.506    319.70809    319.70809    36830.281    36830.281     854.1206     854.1206 
   16000   -15980.114   -15980.114   -16063.866   -16063.866    324.12815    324.12815    36860.052    36860.052    -82.79881    -82.79881 
Loop time of 228.219 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.394 hours/ns, 4.382 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.72     | 227.72     | 227.72     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094194   | 0.094194   | 0.094194   |   0.0 |  0.04
Output  | 0.00015248 | 0.00015248 | 0.00015248 |   0.0 |  0.00
Modify  | 0.34761    | 0.34761    | 0.34761    |   0.0 |  0.15
Other   |            | 0.06059    |            |       |  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:      212514.0 ave      212514 max      212514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212514
Ave neighs/atom = 106.25700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.076579030417, Press = -1.00202210465657
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   -15980.114   -15980.114   -16063.866   -16063.866    324.12815    324.12815    36860.052    36860.052    -82.79881    -82.79881 
   17000   -15981.692   -15981.692   -16061.322   -16061.322    308.17788    308.17788    36871.137    36871.137   -651.37133   -651.37133 
Loop time of 228.347 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.430 hours/ns, 4.379 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.85     | 227.85     | 227.85     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093296   | 0.093296   | 0.093296   |   0.0 |  0.04
Output  | 0.0002038  | 0.0002038  | 0.0002038  |   0.0 |  0.00
Modify  | 0.34746    | 0.34746    | 0.34746    |   0.0 |  0.15
Other   |            | 0.0598     |            |       |  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:      211746.0 ave      211746 max      211746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211746
Ave neighs/atom = 105.87300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.248149094661, Press = 0.648295182585355
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   -15981.692   -15981.692   -16061.322   -16061.322    308.17788    308.17788    36871.137    36871.137   -651.37133   -651.37133 
   18000   -15983.731   -15983.731   -16067.284   -16067.284    323.36019    323.36019    36841.732    36841.732     515.4728     515.4728 
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.094716   | 0.094716   | 0.094716   |   0.0 |  0.04
Output  | 0.00015345 | 0.00015345 | 0.00015345 |   0.0 |  0.00
Modify  | 0.34859    | 0.34859    | 0.34859    |   0.0 |  0.15
Other   |            | 0.06026    |            |       |  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:      211422.0 ave      211422 max      211422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211422
Ave neighs/atom = 105.71100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.422691583059, Press = 1.02724362256855
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   -15983.731   -15983.731   -16067.284   -16067.284    323.36019    323.36019    36841.732    36841.732     515.4728     515.4728 
   19000   -15983.276   -15983.276   -16067.199   -16067.199    324.79322    324.79322    36842.849    36842.849    546.83433    546.83433 
Loop time of 228.799 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.555 hours/ns, 4.371 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.3      | 228.3      | 228.3      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094321   | 0.094321   | 0.094321   |   0.0 |  0.04
Output  | 0.00015354 | 0.00015354 | 0.00015354 |   0.0 |  0.00
Modify  | 0.3493     | 0.3493     | 0.3493     |   0.0 |  0.15
Other   |            | 0.05928    |            |       |  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:      212142.0 ave      212142 max      212142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212142
Ave neighs/atom = 106.07100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.430471058233, Press = -0.729062422095585
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   -15983.276   -15983.276   -16067.199   -16067.199    324.79322    324.79322    36842.849    36842.849    546.83433    546.83433 
   20000   -15983.622   -15983.622   -16063.115   -16063.115    307.64494    307.64494    36812.115    36812.115    2378.1897    2378.1897 
Loop time of 228.748 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.541 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.24     | 228.24     | 228.24     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095012   | 0.095012   | 0.095012   |   0.0 |  0.04
Output  | 0.00015385 | 0.00015385 | 0.00015385 |   0.0 |  0.00
Modify  | 0.34953    | 0.34953    | 0.34953    |   0.0 |  0.15
Other   |            | 0.05949    |            |       |  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:      212216.0 ave      212216 max      212216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212216
Ave neighs/atom = 106.10800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.392852765541, Press = -4.73873520661621
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   -15983.622   -15983.622   -16063.115   -16063.115    307.64494    307.64494    36812.115    36812.115    2378.1897    2378.1897 
   21000   -15986.473   -15986.473   -16067.789   -16067.789    314.69823    314.69823    36845.104    36845.104    213.55698    213.55698 
Loop time of 228.818 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.561 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.31     | 228.31     | 228.31     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094418   | 0.094418   | 0.094418   |   0.0 |  0.04
Output  | 0.00019893 | 0.00019893 | 0.00019893 |   0.0 |  0.00
Modify  | 0.3507     | 0.3507     | 0.3507     |   0.0 |  0.15
Other   |            | 0.0593     |            |       |  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:      212580.0 ave      212580 max      212580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212580
Ave neighs/atom = 106.29000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.426959247574, Press = -5.39594182143779
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   -15986.473   -15986.473   -16067.789   -16067.789    314.69823    314.69823    36845.104    36845.104    213.55698    213.55698 
   22000   -15982.907   -15982.907   -16065.349   -16065.349     319.0594     319.0594    36870.897    36870.897   -954.66118   -954.66118 
Loop time of 229.176 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.660 hours/ns, 4.363 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.67     | 228.67     | 228.67     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096078   | 0.096078   | 0.096078   |   0.0 |  0.04
Output  | 0.00019596 | 0.00019596 | 0.00019596 |   0.0 |  0.00
Modify  | 0.35126    | 0.35126    | 0.35126    |   0.0 |  0.15
Other   |            | 0.05973    |            |       |  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:      212072.0 ave      212072 max      212072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212072
Ave neighs/atom = 106.03600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.389868864768, Press = -2.08721661755736
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   -15982.907   -15982.907   -16065.349   -16065.349     319.0594     319.0594    36870.897    36870.897   -954.66118   -954.66118 
   23000   -15985.829   -15985.829   -16067.551   -16067.551    316.27372    316.27372    36795.413    36795.413    2912.1605    2912.1605 
Loop time of 228.874 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.576 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.094959   | 0.094959   | 0.094959   |   0.0 |  0.04
Output  | 0.0001533  | 0.0001533  | 0.0001533  |   0.0 |  0.00
Modify  | 0.35099    | 0.35099    | 0.35099    |   0.0 |  0.15
Other   |            | 0.05946    |            |       |  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:      211770.0 ave      211770 max      211770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211770
Ave neighs/atom = 105.88500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.301262044975, Press = -1.33610829377847
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   -15985.829   -15985.829   -16067.551   -16067.551    316.27372    316.27372    36795.413    36795.413    2912.1605    2912.1605 
   24000   -15982.631   -15982.631    -16067.03    -16067.03     326.6337     326.6337    36809.583    36809.583       2313.7       2313.7 
Loop time of 229.21 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.669 hours/ns, 4.363 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.7      | 228.7      | 228.7      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095444   | 0.095444   | 0.095444   |   0.0 |  0.04
Output  | 0.00015393 | 0.00015393 | 0.00015393 |   0.0 |  0.00
Modify  | 0.35186    | 0.35186    | 0.35186    |   0.0 |  0.15
Other   |            | 0.05975    |            |       |  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:      212624.0 ave      212624 max      212624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212624
Ave neighs/atom = 106.31200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.219141748911, Press = -5.39538110705913
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   -15982.631   -15982.631    -16067.03    -16067.03     326.6337     326.6337    36809.583    36809.583       2313.7       2313.7 
   25000   -15984.735   -15984.735    -16066.02    -16066.02     314.5803     314.5803    36839.938    36839.938    514.12954    514.12954 
Loop time of 229.229 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.675 hours/ns, 4.362 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.72     | 228.72     | 228.72     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095073   | 0.095073   | 0.095073   |   0.0 |  0.04
Output  | 0.00015404 | 0.00015404 | 0.00015404 |   0.0 |  0.00
Modify  | 0.35211    | 0.35211    | 0.35211    |   0.0 |  0.15
Other   |            | 0.05983    |            |       |  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:      212566.0 ave      212566 max      212566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212566
Ave neighs/atom = 106.28300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.178963142851, Press = -3.07574413269296
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   -15984.735   -15984.735    -16066.02    -16066.02     314.5803     314.5803    36839.938    36839.938    514.12954    514.12954 
   26000   -15985.545   -15985.545   -16065.418   -16065.418    309.11566    309.11566    36887.252    36887.252   -1981.7806   -1981.7806 
Loop time of 250.718 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.345 ns/day, 69.644 hours/ns, 3.989 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    | 250.14     | 250.14     | 250.14     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10306    | 0.10306    | 0.10306    |   0.0 |  0.04
Output  | 0.00018702 | 0.00018702 | 0.00018702 |   0.0 |  0.00
Modify  | 0.40851    | 0.40851    | 0.40851    |   0.0 |  0.16
Other   |            | 0.06417    |            |       |  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:      212144.0 ave      212144 max      212144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212144
Ave neighs/atom = 106.07200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.319374823404, Press = -2.66346594772108
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   -15985.545   -15985.545   -16065.418   -16065.418    309.11566    309.11566    36887.252    36887.252   -1981.7806   -1981.7806 
   27000   -15984.612   -15984.612   -16061.606   -16061.606    297.97471    297.97471    36895.729    36895.729   -1766.0557   -1766.0557 
Loop time of 244.231 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.354 ns/day, 67.842 hours/ns, 4.094 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    | 243.67     | 243.67     | 243.67     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10115    | 0.10115    | 0.10115    |   0.0 |  0.04
Output  | 0.0001528  | 0.0001528  | 0.0001528  |   0.0 |  0.00
Modify  | 0.39466    | 0.39466    | 0.39466    |   0.0 |  0.16
Other   |            | 0.06398    |            |       |  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:      211238.0 ave      211238 max      211238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0