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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 2.86696694791317*${_u_distance}
variable latticeconst_converted equal 2.86696694791317*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86696694791317
Lattice spacing in x,y,z = 2.8669669 2.8669669 2.8669669
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 (28.669669 28.669669 28.669669)
  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 (28.669669 28.669669 28.669669)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_715003088863_000#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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -7933.3252   -7933.3252   -8009.0725   -8009.0725       293.15       293.15    23565.033    23565.033    3433.3382    3433.3382 
    1000   -7988.2584   -7988.2584   -8064.9882   -8064.9882    296.95252    296.95252    21632.917    21632.917   -2224.4566   -2224.4566 
Loop time of 32.3921 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.667 ns/day, 8.998 hours/ns, 30.872 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    | 31.684     | 31.684     | 31.684     |   0.0 | 97.81
Neigh   | 0.14881    | 0.14881    | 0.14881    |   0.0 |  0.46
Comm    | 0.13218    | 0.13218    | 0.13218    |   0.0 |  0.41
Output  | 0.00020315 | 0.00020315 | 0.00020315 |   0.0 |  0.00
Modify  | 0.36202    | 0.36202    | 0.36202    |   0.0 |  1.12
Other   |            | 0.06457    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5471.00 ave        5471 max        5471 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:      333230.0 ave      333230 max      333230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333230
Ave neighs/atom = 166.61500
Neighbor list builds = 3
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -7988.2584   -7988.2584   -8064.9882   -8064.9882    296.95252    296.95252    21632.917    21632.917   -2224.4566   -2224.4566 
    2000   -8017.0672   -8017.0672    -8094.968    -8094.968    301.48405    301.48405    21609.625    21609.625   -1196.8663   -1196.8663 
Loop time of 32.0086 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.699 ns/day, 8.891 hours/ns, 31.242 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    | 31.325     | 31.325     | 31.325     |   0.0 | 97.86
Neigh   | 0.14304    | 0.14304    | 0.14304    |   0.0 |  0.45
Comm    | 0.12722    | 0.12722    | 0.12722    |   0.0 |  0.40
Output  | 0.00018905 | 0.00018905 | 0.00018905 |   0.0 |  0.00
Modify  | 0.3486     | 0.3486     | 0.3486     |   0.0 |  1.09
Other   |            | 0.06438    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 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:      332600.0 ave      332600 max      332600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332600
Ave neighs/atom = 166.30000
Neighbor list builds = 3
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8017.0672   -8017.0672    -8094.968    -8094.968    301.48405    301.48405    21609.625    21609.625   -1196.8663   -1196.8663 
    3000   -8019.8871   -8019.8871   -8096.6068   -8096.6068    296.91341    296.91341    21574.686    21574.686    1171.3798    1171.3798 
Loop time of 31.7094 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.725 ns/day, 8.808 hours/ns, 31.536 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    | 31.168     | 31.168     | 31.168     |   0.0 | 98.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12544    | 0.12544    | 0.12544    |   0.0 |  0.40
Output  | 0.000189   | 0.000189   | 0.000189   |   0.0 |  0.00
Modify  | 0.34987    | 0.34987    | 0.34987    |   0.0 |  1.10
Other   |            | 0.06582    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5420.00 ave        5420 max        5420 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:      331950.0 ave      331950 max      331950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331950
Ave neighs/atom = 165.97500
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8019.8871   -8019.8871   -8096.6068   -8096.6068    296.91341    296.91341    21574.686    21574.686    1171.3798    1171.3798 
    4000   -8022.2406   -8022.2406   -8099.3341   -8099.3341     298.3601     298.3601    21562.092    21562.092     573.8278     573.8278 
Loop time of 33.1325 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.608 ns/day, 9.203 hours/ns, 30.182 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    | 32.574     | 32.574     | 32.574     |   0.0 | 98.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12879    | 0.12879    | 0.12879    |   0.0 |  0.39
Output  | 0.00018751 | 0.00018751 | 0.00018751 |   0.0 |  0.00
Modify  | 0.36388    | 0.36388    | 0.36388    |   0.0 |  1.10
Other   |            | 0.06582    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5445.00 ave        5445 max        5445 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:      332330.0 ave      332330 max      332330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332330
Ave neighs/atom = 166.16500
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8022.2406   -8022.2406   -8099.3341   -8099.3341     298.3601     298.3601    21562.092    21562.092     573.8278     573.8278 
    5000   -8020.7296   -8020.7296   -8095.6024   -8095.6024    289.76547    289.76547    21533.672    21533.672    3507.8219    3507.8219 
Loop time of 32.364 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.670 ns/day, 8.990 hours/ns, 30.898 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    | 31.815     | 31.815     | 31.815     |   0.0 | 98.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12576    | 0.12576    | 0.12576    |   0.0 |  0.39
Output  | 0.00015223 | 0.00015223 | 0.00015223 |   0.0 |  0.00
Modify  | 0.35834    | 0.35834    | 0.35834    |   0.0 |  1.11
Other   |            | 0.06513    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 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:      332834.0 ave      332834 max      332834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332834
Ave neighs/atom = 166.41700
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 = 294.338837284246, Press = 116.297756971378
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8020.7296   -8020.7296   -8095.6024   -8095.6024    289.76547    289.76547    21533.672    21533.672    3507.8219    3507.8219 
    6000    -8019.022    -8019.022   -8097.4423   -8097.4423     303.4948     303.4948    21608.275    21608.275   -1656.5121   -1656.5121 
Loop time of 32.6319 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.648 ns/day, 9.064 hours/ns, 30.645 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    | 32.065     | 32.065     | 32.065     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12633    | 0.12633    | 0.12633    |   0.0 |  0.39
Output  | 0.0001553  | 0.0001553  | 0.0001553  |   0.0 |  0.00
Modify  | 0.3761     | 0.3761     | 0.3761     |   0.0 |  1.15
Other   |            | 0.06463    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5424.00 ave        5424 max        5424 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:      333050.0 ave      333050 max      333050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333050
Ave neighs/atom = 166.52500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.222236105162, Press = 24.8879174623137
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000    -8019.022    -8019.022   -8097.4423   -8097.4423     303.4948     303.4948    21608.275    21608.275   -1656.5121   -1656.5121 
    7000    -8022.755    -8022.755   -8097.4874   -8097.4874    289.22198    289.22198     21601.42     21601.42   -1354.5478   -1354.5478 
Loop time of 33.1713 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.605 ns/day, 9.214 hours/ns, 30.147 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    | 32.593     | 32.593     | 32.593     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12778    | 0.12778    | 0.12778    |   0.0 |  0.39
Output  | 0.00015658 | 0.00015658 | 0.00015658 |   0.0 |  0.00
Modify  | 0.38424    | 0.38424    | 0.38424    |   0.0 |  1.16
Other   |            | 0.06571    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 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:      332154.0 ave      332154 max      332154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332154
Ave neighs/atom = 166.07700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.531737549694, Press = 15.1694058262211
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000    -8022.755    -8022.755   -8097.4874   -8097.4874    289.22198    289.22198     21601.42     21601.42   -1354.5478   -1354.5478 
    8000   -8020.2157   -8020.2157   -8096.1795   -8096.1795    293.98792    293.98792    21551.578    21551.578     2728.981     2728.981 
Loop time of 32.6528 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.646 ns/day, 9.070 hours/ns, 30.625 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    | 32.086     | 32.086     | 32.086     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12598    | 0.12598    | 0.12598    |   0.0 |  0.39
Output  | 0.00015173 | 0.00015173 | 0.00015173 |   0.0 |  0.00
Modify  | 0.37575    | 0.37575    | 0.37575    |   0.0 |  1.15
Other   |            | 0.06517    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5406.00 ave        5406 max        5406 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:      332078.0 ave      332078 max      332078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332078
Ave neighs/atom = 166.03900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.916805330038, Press = 2.58805074680087
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8020.2157   -8020.2157   -8096.1795   -8096.1795    293.98792    293.98792    21551.578    21551.578     2728.981     2728.981 
    9000   -8024.8704   -8024.8704   -8100.2766   -8100.2766    291.82958    291.82958    21554.344    21554.344    943.63842    943.63842 
Loop time of 32.7645 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.637 ns/day, 9.101 hours/ns, 30.521 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    | 32.198     | 32.198     | 32.198     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12693    | 0.12693    | 0.12693    |   0.0 |  0.39
Output  | 0.00014373 | 0.00014373 | 0.00014373 |   0.0 |  0.00
Modify  | 0.37436    | 0.37436    | 0.37436    |   0.0 |  1.14
Other   |            | 0.0647     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5406.00 ave        5406 max        5406 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:      333102.0 ave      333102 max      333102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333102
Ave neighs/atom = 166.55100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.482307342093, Press = -2.22549896704993
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8024.8704   -8024.8704   -8100.2766   -8100.2766    291.82958    291.82958    21554.344    21554.344    943.63842    943.63842 
   10000    -8021.124    -8021.124   -8097.4828   -8097.4828    295.51649    295.51649    21594.597    21594.597   -1536.9394   -1536.9394 
Loop time of 32.8851 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.627 ns/day, 9.135 hours/ns, 30.409 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    | 32.312     | 32.312     | 32.312     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12737    | 0.12737    | 0.12737    |   0.0 |  0.39
Output  | 0.00015546 | 0.00015546 | 0.00015546 |   0.0 |  0.00
Modify  | 0.37975    | 0.37975    | 0.37975    |   0.0 |  1.15
Other   |            | 0.06539    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 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:      332908.0 ave      332908 max      332908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332908
Ave neighs/atom = 166.45400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.254620951579, Press = -4.54748029989937
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000    -8021.124    -8021.124   -8097.4828   -8097.4828    295.51649    295.51649    21594.597    21594.597   -1536.9394   -1536.9394 
   11000   -8018.6374   -8018.6374   -8094.5482   -8094.5482    293.78254    293.78254    21585.568    21585.568    239.99793    239.99793 
Loop time of 32.3923 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.667 ns/day, 8.998 hours/ns, 30.871 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    | 31.829     | 31.829     | 31.829     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12595    | 0.12595    | 0.12595    |   0.0 |  0.39
Output  | 0.00024168 | 0.00024168 | 0.00024168 |   0.0 |  0.00
Modify  | 0.37216    | 0.37216    | 0.37216    |   0.0 |  1.15
Other   |            | 0.06513    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 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:      332138.0 ave      332138 max      332138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332138
Ave neighs/atom = 166.06900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.302881065443, Press = -13.6351134563597
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8018.6374   -8018.6374   -8094.5482   -8094.5482    293.78254    293.78254    21585.568    21585.568    239.99793    239.99793 
   12000   -8021.7084   -8021.7084   -8098.1648   -8098.1648    295.89414    295.89414    21545.733    21545.733    976.53692    976.53692 
Loop time of 33.3643 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.590 ns/day, 9.268 hours/ns, 29.972 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    | 32.785     | 32.785     | 32.785     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12881    | 0.12881    | 0.12881    |   0.0 |  0.39
Output  | 0.00015479 | 0.00015479 | 0.00015479 |   0.0 |  0.00
Modify  | 0.38505    | 0.38505    | 0.38505    |   0.0 |  1.15
Other   |            | 0.06572    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 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:      332422.0 ave      332422 max      332422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332422
Ave neighs/atom = 166.21100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.723114587865, Press = 4.13073037068298
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8021.7084   -8021.7084   -8098.1648   -8098.1648    295.89414    295.89414    21545.733    21545.733    976.53692    976.53692 
   13000   -8019.4313   -8019.4313   -8096.0777   -8096.0777    296.62954    296.62954    21559.083    21559.083    2407.2466    2407.2466 
Loop time of 32.353 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.671 ns/day, 8.987 hours/ns, 30.909 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    | 31.794     | 31.794     | 31.794     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12435    | 0.12435    | 0.12435    |   0.0 |  0.38
Output  | 0.00015202 | 0.00015202 | 0.00015202 |   0.0 |  0.00
Modify  | 0.37007    | 0.37007    | 0.37007    |   0.0 |  1.14
Other   |            | 0.06444    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 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:      333156.0 ave      333156 max      333156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333156
Ave neighs/atom = 166.57800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.676162982324, Press = -5.35648910227818
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8019.4313   -8019.4313   -8096.0777   -8096.0777    296.62954    296.62954    21559.083    21559.083    2407.2466    2407.2466 
   14000   -8021.7485   -8021.7485   -8096.3561   -8096.3561    288.73896    288.73896    21587.609    21587.609    307.63142    307.63142 
Loop time of 32.8407 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.631 ns/day, 9.122 hours/ns, 30.450 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    | 32.27      | 32.27      | 32.27      |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12638    | 0.12638    | 0.12638    |   0.0 |  0.38
Output  | 0.00015278 | 0.00015278 | 0.00015278 |   0.0 |  0.00
Modify  | 0.37893    | 0.37893    | 0.37893    |   0.0 |  1.15
Other   |            | 0.06545    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5433.00 ave        5433 max        5433 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:      332464.0 ave      332464 max      332464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332464
Ave neighs/atom = 166.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 = 293.486254719674, Press = 0.231334621809144
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8021.7485   -8021.7485   -8096.3561   -8096.3561    288.73896    288.73896    21587.609    21587.609    307.63142    307.63142 
   15000   -8022.6091   -8022.6091   -8098.6666   -8098.6666     294.3501     294.3501    21615.809    21615.809   -1837.0019   -1837.0019 
Loop time of 32.9402 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.623 ns/day, 9.150 hours/ns, 30.358 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    | 32.366     | 32.366     | 32.366     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12734    | 0.12734    | 0.12734    |   0.0 |  0.39
Output  | 0.00016444 | 0.00016444 | 0.00016444 |   0.0 |  0.00
Modify  | 0.3816     | 0.3816     | 0.3816     |   0.0 |  1.16
Other   |            | 0.06544    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5424.00 ave        5424 max        5424 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:      332192.0 ave      332192 max      332192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332192
Ave neighs/atom = 166.09600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.50858447864, Press = -6.34048088407465
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8022.6091   -8022.6091   -8098.6666   -8098.6666     294.3501     294.3501    21615.809    21615.809   -1837.0019   -1837.0019 
   16000    -8021.741    -8021.741   -8098.6996   -8098.6996    297.83761    297.83761    21594.202    21594.202   -1921.7795   -1921.7795 
Loop time of 32.59 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.651 ns/day, 9.053 hours/ns, 30.684 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    | 32.026     | 32.026     | 32.026     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.126      | 0.126      | 0.126      |   0.0 |  0.39
Output  | 0.00020257 | 0.00020257 | 0.00020257 |   0.0 |  0.00
Modify  | 0.37285    | 0.37285    | 0.37285    |   0.0 |  1.14
Other   |            | 0.06495    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 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:      331680.0 ave      331680 max      331680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331680
Ave neighs/atom = 165.84000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.624624303264, Press = -1.24704365801449
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000    -8021.741    -8021.741   -8098.6996   -8098.6996    297.83761    297.83761    21594.202    21594.202   -1921.7795   -1921.7795 
   17000   -8019.0433   -8019.0433   -8093.7523   -8093.7523    289.13144    289.13144    21589.156    21589.156       741.66       741.66 
Loop time of 32.1199 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.690 ns/day, 8.922 hours/ns, 31.133 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    | 31.559     | 31.559     | 31.559     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12494    | 0.12494    | 0.12494    |   0.0 |  0.39
Output  | 0.00015485 | 0.00015485 | 0.00015485 |   0.0 |  0.00
Modify  | 0.37119    | 0.37119    | 0.37119    |   0.0 |  1.16
Other   |            | 0.0648     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 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:      332144.0 ave      332144 max      332144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332144
Ave neighs/atom = 166.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 = 293.593850610554, Press = -2.69119599438597
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8019.0433   -8019.0433   -8093.7523   -8093.7523    289.13144    289.13144    21589.156    21589.156       741.66       741.66 
   18000   -8020.9949   -8020.9949   -8098.9866   -8098.9866    301.83626    301.83626    21526.869    21526.869    3674.6986    3674.6986 
Loop time of 33.1427 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.607 ns/day, 9.206 hours/ns, 30.173 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    | 32.522     | 32.522     | 32.522     |   0.0 | 98.13
Neigh   | 0.046855   | 0.046855   | 0.046855   |   0.0 |  0.14
Comm    | 0.12806    | 0.12806    | 0.12806    |   0.0 |  0.39
Output  | 0.00015379 | 0.00015379 | 0.00015379 |   0.0 |  0.00
Modify  | 0.38051    | 0.38051    | 0.38051    |   0.0 |  1.15
Other   |            | 0.06502    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 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:      333378.0 ave      333378 max      333378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333378
Ave neighs/atom = 166.68900
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.585386598231, Press = 3.78277119719594
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8020.9949   -8020.9949   -8098.9866   -8098.9866    301.83626    301.83626    21526.869    21526.869    3674.6986    3674.6986 
   19000   -8022.1072   -8022.1072   -8096.8096   -8096.8096    289.10605    289.10605    21627.325    21627.325    -929.5174    -929.5174 
Loop time of 32.5601 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.654 ns/day, 9.044 hours/ns, 30.712 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    | 31.994     | 31.994     | 31.994     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12643    | 0.12643    | 0.12643    |   0.0 |  0.39
Output  | 0.00024303 | 0.00024303 | 0.00024303 |   0.0 |  0.00
Modify  | 0.37424    | 0.37424    | 0.37424    |   0.0 |  1.15
Other   |            | 0.06491    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 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:      333376.0 ave      333376 max      333376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333376
Ave neighs/atom = 166.68800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.55067375752, Press = 2.28369046921005
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8022.1072   -8022.1072   -8096.8096   -8096.8096    289.10605    289.10605    21627.325    21627.325    -929.5174    -929.5174 
   20000   -8022.8379   -8022.8379   -8099.4933   -8099.4933     296.6643     296.6643    21589.158    21589.158    1058.0912    1058.0912 
Loop time of 32.7161 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.641 ns/day, 9.088 hours/ns, 30.566 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    | 32.152     | 32.152     | 32.152     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12551    | 0.12551    | 0.12551    |   0.0 |  0.38
Output  | 0.00015391 | 0.00015391 | 0.00015391 |   0.0 |  0.00
Modify  | 0.3737     | 0.3737     | 0.3737     |   0.0 |  1.14
Other   |            | 0.06514    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 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:      331856.0 ave      331856 max      331856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331856
Ave neighs/atom = 165.92800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.477046426548, Press = 4.30194352262064
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8022.8379   -8022.8379   -8099.4933   -8099.4933     296.6643     296.6643    21589.158    21589.158    1058.0912    1058.0912 
   21000   -8026.4194   -8026.4194     -8101.45     -8101.45    290.37593    290.37593    21546.314    21546.314    2445.3751    2445.3751 
Loop time of 32.5019 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.658 ns/day, 9.028 hours/ns, 30.767 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    | 31.938     | 31.938     | 31.938     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12681    | 0.12681    | 0.12681    |   0.0 |  0.39
Output  | 0.00020123 | 0.00020123 | 0.00020123 |   0.0 |  0.00
Modify  | 0.37226    | 0.37226    | 0.37226    |   0.0 |  1.15
Other   |            | 0.06481    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 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:      333014.0 ave      333014 max      333014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333014
Ave neighs/atom = 166.50700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.358622576178, Press = 0.754489271832185
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8026.4194   -8026.4194     -8101.45     -8101.45    290.37593    290.37593    21546.314    21546.314    2445.3751    2445.3751 
   22000   -8024.2704   -8024.2704   -8098.7968   -8098.7968    288.42466    288.42466     21618.04     21618.04    -1812.357    -1812.357 
Loop time of 32.5155 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.657 ns/day, 9.032 hours/ns, 30.755 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    | 31.953     | 31.953     | 31.953     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12546    | 0.12546    | 0.12546    |   0.0 |  0.39
Output  | 0.0001633  | 0.0001633  | 0.0001633  |   0.0 |  0.00
Modify  | 0.37228    | 0.37228    | 0.37228    |   0.0 |  1.14
Other   |            | 0.06504    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5424.00 ave        5424 max        5424 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:      333288.0 ave      333288 max      333288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333288
Ave neighs/atom = 166.64400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.324085600779, Press = 4.49327705659397
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8024.2704   -8024.2704   -8098.7968   -8098.7968    288.42466    288.42466     21618.04     21618.04    -1812.357    -1812.357 
   23000   -8021.0758   -8021.0758   -8097.6606   -8097.6606     296.3911     296.3911    21625.049    21625.049   -1878.6085   -1878.6085 
Loop time of 33.3561 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.590 ns/day, 9.266 hours/ns, 29.980 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    | 32.779     | 32.779     | 32.779     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12845    | 0.12845    | 0.12845    |   0.0 |  0.39
Output  | 0.00019218 | 0.00019218 | 0.00019218 |   0.0 |  0.00
Modify  | 0.38304    | 0.38304    | 0.38304    |   0.0 |  1.15
Other   |            | 0.06512    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 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:      332256.0 ave      332256 max      332256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332256
Ave neighs/atom = 166.12800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.427287924488, Press = -1.07731589745455
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8021.0758   -8021.0758   -8097.6606   -8097.6606     296.3911     296.3911    21625.049    21625.049   -1878.6085   -1878.6085 
   24000   -8021.8455   -8021.8455   -8097.7514   -8097.7514    293.76372    293.76372    21573.308    21573.308    1328.7941    1328.7941 
Loop time of 32.7395 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.639 ns/day, 9.094 hours/ns, 30.544 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    | 32.171     | 32.171     | 32.171     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12689    | 0.12689    | 0.12689    |   0.0 |  0.39
Output  | 0.0001505  | 0.0001505  | 0.0001505  |   0.0 |  0.00
Modify  | 0.37671    | 0.37671    | 0.37671    |   0.0 |  1.15
Other   |            | 0.06468    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5407.00 ave        5407 max        5407 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:      332194.0 ave      332194 max      332194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332194
Ave neighs/atom = 166.09700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.400590510054, Press = -1.62517238437684
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8021.8455   -8021.8455   -8097.7514   -8097.7514    293.76372    293.76372    21573.308    21573.308    1328.7941    1328.7941 
   25000   -8019.8823   -8019.8823   -8095.4012   -8095.4012    292.26587    292.26587    21625.161    21625.161    675.33995    675.33995 
Loop time of 33.8717 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.551 ns/day, 9.409 hours/ns, 29.523 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    | 33.289     | 33.289     | 33.289     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12996    | 0.12996    | 0.12996    |   0.0 |  0.38
Output  | 0.00024281 | 0.00024281 | 0.00024281 |   0.0 |  0.00
Modify  | 0.38728    | 0.38728    | 0.38728    |   0.0 |  1.14
Other   |            | 0.0651     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 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:      332786.0 ave      332786 max      332786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332786
Ave neighs/atom = 166.39300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.379227012039, Press = 2.55028478701675
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8019.8823   -8019.8823   -8095.4012   -8095.4012    292.26587    292.26587    21625.161    21625.161    675.33995    675.33995 
   26000   -8024.5861   -8024.5861   -8100.1067   -8100.1067    292.27276    292.27276    21620.987    21620.987   -1162.7078   -1162.7078 
Loop time of 32.9474 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.622 ns/day, 9.152 hours/ns, 30.351 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    | 32.377     | 32.377     | 32.377     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12708    | 0.12708    | 0.12708    |   0.0 |  0.39
Output  | 0.00014765 | 0.00014765 | 0.00014765 |   0.0 |  0.00
Modify  | 0.37788    | 0.37788    | 0.37788    |   0.0 |  1.15
Other   |            | 0.06501    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 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:      332252.0 ave      332252 max      332252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332252
Ave neighs/atom = 166.12600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.440171416471, Press = -2.71677052667768
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8024.5861   -8024.5861   -8100.1067   -8100.1067    292.27276    292.27276    21620.987    21620.987   -1162.7078   -1162.7078 
   27000   -8025.3368   -8025.3368   -8100.0176   -8100.0176    289.02238    289.02238    21587.498    21587.498   -973.57806   -973.57806 
Loop time of 31.7905 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.718 ns/day, 8.831 hours/ns, 31.456 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    | 31.232     | 31.232     | 31.232     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12508    | 0.12508    | 0.12508    |   0.0 |  0.39
Output  | 0.00015464 | 0.00015464 | 0.00015464 |   0.0 |  0.00
Modify  | 0.36801    | 0.36801    | 0.36801    |   0.0 |  1.16
Other   |            | 0.06501    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 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:      331934.0 ave      331934 max      331934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331934
Ave neighs/atom = 165.96700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.398214862274, Press = -2.4269183230325
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8025.3368   -8025.3368   -8100.0176   -8100.0176    289.02238    289.02238    21587.498    21587.498   -973.57806   -973.57806 
   28000   -8022.7848   -8022.7848   -8098.5939   -8098.5939    293.38922    293.38922    21597.665    21597.665   -117.93277   -117.93277 
Loop time of 33.0763 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.612 ns/day, 9.188 hours/ns, 30.233 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    | 32.501     | 32.501     | 32.501     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12734    | 0.12734    | 0.12734    |   0.0 |  0.38
Output  | 0.00015056 | 0.00015056 | 0.00015056 |   0.0 |  0.00
Modify  | 0.38182    | 0.38182    | 0.38182    |   0.0 |  1.15
Other   |            | 0.06563    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5418.00 ave        5418 max        5418 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:      332468.0 ave      332468 max      332468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332468
Ave neighs/atom = 166.23400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.28669380082, Press = -2.13045849537279
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8022.7848   -8022.7848   -8098.5939   -8098.5939    293.38922    293.38922    21597.665    21597.665   -117.93277   -117.93277 
   29000   -8025.7047   -8025.7047   -8101.1044   -8101.1044    291.80438    291.80438    21577.606    21577.606      180.178      180.178 
Loop time of 33.3927 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.587 ns/day, 9.276 hours/ns, 29.947 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    | 32.811     | 32.811     | 32.811     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12844    | 0.12844    | 0.12844    |   0.0 |  0.38
Output  | 0.00019864 | 0.00019864 | 0.00019864 |   0.0 |  0.00
Modify  | 0.3872     | 0.3872     | 0.3872     |   0.0 |  1.16
Other   |            | 0.06558    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5415.00 ave        5415 max        5415 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:      332690.0 ave      332690 max      332690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0