# 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.850243076682091*${_u_distance}
variable latticeconst_converted equal 2.850243076682091*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85024307668209
Lattice spacing in x,y,z = 2.8502431 2.8502431 2.8502431
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.502431 28.502431 28.502431)
  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.502431 28.502431 28.502431)
  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 MEAM_LAMMPS_MahataMukhopadhyayAsleZaeem_2022_AlFe__MO_304347095149_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 23155.0486762528    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23155.0486762528/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23155.0486762528/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23155.0486762528/(1*1*${_u_distance})
variable      V0_metal equal 23155.0486762528/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23155.0486762528*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23155.0486762528 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_304347095149_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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8504.9304   -8504.9304   -8580.6777   -8580.6777       293.15       293.15    23155.049    23155.049    3494.1402    3494.1402 
    1000   -8426.3946   -8426.3946   -8501.6375   -8501.6375    291.19799    291.19799    23333.565    23333.565    2945.1721    2945.1721 
Loop time of 243.226 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.355 ns/day, 67.563 hours/ns, 4.111 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    | 242.69     | 242.69     | 242.69     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10041    | 0.10041    | 0.10041    |   0.0 |  0.04
Output  | 0.00020127 | 0.00020127 | 0.00020127 |   0.0 |  0.00
Modify  | 0.37134    | 0.37134    | 0.37134    |   0.0 |  0.15
Other   |            | 0.06114    |            |       |  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:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.000000
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8426.3946   -8426.3946   -8501.6375   -8501.6375    291.19799    291.19799    23333.565    23333.565    2945.1721    2945.1721 
    2000   -8425.9512   -8425.9512   -8500.1523   -8500.1523    287.16625    287.16625    23362.386    23362.386    1086.2642    1086.2642 
Loop time of 237.792 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.363 ns/day, 66.053 hours/ns, 4.205 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    | 237.27     | 237.27     | 237.27     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099506   | 0.099506   | 0.099506   |   0.0 |  0.04
Output  | 0.00026801 | 0.00026801 | 0.00026801 |   0.0 |  0.00
Modify  | 0.35812    | 0.35812    | 0.35812    |   0.0 |  0.15
Other   |            | 0.06025    |            |       |  0.03

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

Total # of neighbors = 132616
Ave neighs/atom = 66.308000
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8425.9512   -8425.9512   -8500.1523   -8500.1523    287.16625    287.16625    23362.386    23362.386    1086.2642    1086.2642 
    3000   -8427.5267   -8427.5267   -8506.6048   -8506.6048     306.0402     306.0402    23349.687    23349.687    1276.6693    1276.6693 
Loop time of 254.132 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 253.57     | 253.57     | 253.57     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10543    | 0.10543    | 0.10543    |   0.0 |  0.04
Output  | 0.00019209 | 0.00019209 | 0.00019209 |   0.0 |  0.00
Modify  | 0.39744    | 0.39744    | 0.39744    |   0.0 |  0.16
Other   |            | 0.06301    |            |       |  0.02

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

Total # of neighbors = 132182
Ave neighs/atom = 66.091000
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8427.5267   -8427.5267   -8506.6048   -8506.6048     306.0402     306.0402    23349.687    23349.687    1276.6693    1276.6693 
    4000   -8425.4629   -8425.4629   -8500.1824   -8500.1824    289.17191    289.17191    23349.094    23349.094    2129.9938    2129.9938 
Loop time of 263.048 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.328 ns/day, 73.069 hours/ns, 3.802 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    | 262.46     | 262.46     | 262.46     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10868    | 0.10868    | 0.10868    |   0.0 |  0.04
Output  | 0.00019194 | 0.00019194 | 0.00019194 |   0.0 |  0.00
Modify  | 0.41627    | 0.41627    | 0.41627    |   0.0 |  0.16
Other   |            | 0.06503    |            |       |  0.02

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

Total # of neighbors = 131476
Ave neighs/atom = 65.738000
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8425.4629   -8425.4629   -8500.1824   -8500.1824    289.17191    289.17191    23349.094    23349.094    2129.9938    2129.9938 
    5000   -8427.9406   -8427.9406   -8505.2002   -8505.2002    299.00251    299.00251    23346.451    23346.451     1691.369     1691.369 
Loop time of 261.664 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.330 ns/day, 72.684 hours/ns, 3.822 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 261.07     | 261.07     | 261.07     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10882    | 0.10882    | 0.10882    |   0.0 |  0.04
Output  | 0.00025608 | 0.00025608 | 0.00025608 |   0.0 |  0.00
Modify  | 0.41872    | 0.41872    | 0.41872    |   0.0 |  0.16
Other   |            | 0.06475    |            |       |  0.02

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

Total # of neighbors = 132166
Ave neighs/atom = 66.083000
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 = 288.8417105167, Press = -742.503342959069
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8427.9406   -8427.9406   -8505.2002   -8505.2002    299.00251    299.00251    23346.451    23346.451     1691.369     1691.369 
    6000   -8425.9374   -8425.9374   -8498.7125   -8498.7125    281.64718    281.64718     23350.88     23350.88     2211.808     2211.808 
Loop time of 249.57 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.346 ns/day, 69.325 hours/ns, 4.007 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    | 248.99     | 248.99     | 248.99     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10399    | 0.10399    | 0.10399    |   0.0 |  0.04
Output  | 0.00015631 | 0.00015631 | 0.00015631 |   0.0 |  0.00
Modify  | 0.40834    | 0.40834    | 0.40834    |   0.0 |  0.16
Other   |            | 0.06291    |            |       |  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:      131760.0 ave      131760 max      131760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131760
Ave neighs/atom = 65.880000
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.184128203806, Press = -91.153264506414
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8425.9374   -8425.9374   -8498.7125   -8498.7125    281.64718    281.64718     23350.88     23350.88     2211.808     2211.808 
    7000    -8427.415    -8427.415   -8500.7744   -8500.7744    283.90827    283.90827    23337.899    23337.899    2802.0404    2802.0404 
Loop time of 241.144 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.358 ns/day, 66.985 hours/ns, 4.147 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 240.6      | 240.6      | 240.6      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10049    | 0.10049    | 0.10049    |   0.0 |  0.04
Output  | 0.00019321 | 0.00019321 | 0.00019321 |   0.0 |  0.00
Modify  | 0.38375    | 0.38375    | 0.38375    |   0.0 |  0.16
Other   |            | 0.06038    |            |       |  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:      132180.0 ave      132180 max      132180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 132180
Ave neighs/atom = 66.090000
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.511751524244, Press = -60.2135325985273
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000    -8427.415    -8427.415   -8500.7744   -8500.7744    283.90827    283.90827    23337.899    23337.899    2802.0404    2802.0404 
    8000   -8426.4444   -8426.4444   -8502.9679   -8502.9679     296.1536     296.1536    23366.912    23366.912    613.40586    613.40586 
Loop time of 262.748 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.329 ns/day, 72.986 hours/ns, 3.806 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    | 262.14     | 262.14     | 262.14     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10905    | 0.10905    | 0.10905    |   0.0 |  0.04
Output  | 0.00019803 | 0.00019803 | 0.00019803 |   0.0 |  0.00
Modify  | 0.4346     | 0.4346     | 0.4346     |   0.0 |  0.17
Other   |            | 0.06347    |            |       |  0.02

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

Total # of neighbors = 132128
Ave neighs/atom = 66.064000
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.344696894639, Press = -35.7318103551932
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8426.4444   -8426.4444   -8502.9679   -8502.9679     296.1536     296.1536    23366.912    23366.912    613.40586    613.40586 
    9000   -8424.3616   -8424.3616     -8501.33     -8501.33    297.87581    297.87581    23382.154    23382.154   -153.65838   -153.65838 
Loop time of 263.32 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.328 ns/day, 73.144 hours/ns, 3.798 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    | 262.71     | 262.71     | 262.71     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10906    | 0.10906    | 0.10906    |   0.0 |  0.04
Output  | 0.00015866 | 0.00015866 | 0.00015866 |   0.0 |  0.00
Modify  | 0.43992    | 0.43992    | 0.43992    |   0.0 |  0.17
Other   |            | 0.06555    |            |       |  0.02

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

Total # of neighbors = 131720
Ave neighs/atom = 65.860000
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.546765720866, Press = -15.8417998646845
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8424.3616   -8424.3616     -8501.33     -8501.33    297.87581    297.87581    23382.154    23382.154   -153.65838   -153.65838 
   10000   -8426.7044   -8426.7044   -8503.4737   -8503.4737    297.10486    297.10486    23389.331    23389.331   -907.99632   -907.99632 
Loop time of 258.826 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.334 ns/day, 71.896 hours/ns, 3.864 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    | 258.22     | 258.22     | 258.22     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10864    | 0.10864    | 0.10864    |   0.0 |  0.04
Output  | 0.0001602  | 0.0001602  | 0.0001602  |   0.0 |  0.00
Modify  | 0.42958    | 0.42958    | 0.42958    |   0.0 |  0.17
Other   |            | 0.06428    |            |       |  0.02

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

Total # of neighbors = 131818
Ave neighs/atom = 65.909000
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.713362585653, Press = -16.8396228588925
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8426.7044   -8426.7044   -8503.4737   -8503.4737    297.10486    297.10486    23389.331    23389.331   -907.99632   -907.99632 
   11000   -8427.7359   -8427.7359   -8503.2025   -8503.2025    292.06353    292.06353    23391.477    23391.477   -1142.3308   -1142.3308 
Loop time of 263.892 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.327 ns/day, 73.303 hours/ns, 3.789 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    | 263.28     | 263.28     | 263.28     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1091     | 0.1091     | 0.1091     |   0.0 |  0.04
Output  | 0.0002017  | 0.0002017  | 0.0002017  |   0.0 |  0.00
Modify  | 0.44089    | 0.44089    | 0.44089    |   0.0 |  0.17
Other   |            | 0.06464    |            |       |  0.02

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

Total # of neighbors = 131608
Ave neighs/atom = 65.804000
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.303113386622, Press = -16.4874241468896
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8427.7359   -8427.7359   -8503.2025   -8503.2025    292.06353    292.06353    23391.477    23391.477   -1142.3308   -1142.3308 
   12000   -8425.7733   -8425.7733   -8500.5918   -8500.5918     289.5556     289.5556    23425.448    23425.448   -3166.0316   -3166.0316 
Loop time of 263.464 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.328 ns/day, 73.184 hours/ns, 3.796 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    | 262.85     | 262.85     | 262.85     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10903    | 0.10903    | 0.10903    |   0.0 |  0.04
Output  | 0.00023938 | 0.00023938 | 0.00023938 |   0.0 |  0.00
Modify  | 0.44207    | 0.44207    | 0.44207    |   0.0 |  0.17
Other   |            | 0.06488    |            |       |  0.02

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

Total # of neighbors = 131654
Ave neighs/atom = 65.827000
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.382704484263, Press = -18.6272189603364
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8425.7733   -8425.7733   -8500.5918   -8500.5918     289.5556     289.5556    23425.448    23425.448   -3166.0316   -3166.0316 
   13000   -8422.9786   -8422.9786   -8500.2649   -8500.2649    299.10611    299.10611     23415.12     23415.12   -2269.3647   -2269.3647 
Loop time of 245.021 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.353 ns/day, 68.061 hours/ns, 4.081 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    | 244.46     | 244.46     | 244.46     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10261    | 0.10261    | 0.10261    |   0.0 |  0.04
Output  | 0.00015613 | 0.00015613 | 0.00015613 |   0.0 |  0.00
Modify  | 0.39409    | 0.39409    | 0.39409    |   0.0 |  0.16
Other   |            | 0.06143    |            |       |  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:      131476.0 ave      131476 max      131476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131476
Ave neighs/atom = 65.738000
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.271907191952, Press = -9.04440827260607
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8422.9786   -8422.9786   -8500.2649   -8500.2649    299.10611    299.10611     23415.12     23415.12   -2269.3647   -2269.3647 
   14000   -8427.7442   -8427.7442      -8503.5      -8503.5    293.18264    293.18264    23393.335    23393.335   -1359.3132   -1359.3132 
Loop time of 249.245 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.347 ns/day, 69.235 hours/ns, 4.012 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    | 248.67     | 248.67     | 248.67     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10541    | 0.10541    | 0.10541    |   0.0 |  0.04
Output  | 0.00019319 | 0.00019319 | 0.00019319 |   0.0 |  0.00
Modify  | 0.40531    | 0.40531    | 0.40531    |   0.0 |  0.16
Other   |            | 0.06313    |            |       |  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:      131632.0 ave      131632 max      131632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131632
Ave neighs/atom = 65.816000
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.405792305746, Press = -8.54011974209737
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8427.7442   -8427.7442      -8503.5      -8503.5    293.18264    293.18264    23393.335    23393.335   -1359.3132   -1359.3132 
   15000   -8425.3169   -8425.3169   -8502.4659   -8502.4659    298.57442    298.57442    23399.863    23399.863   -1603.5294   -1603.5294 
Loop time of 245.556 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.352 ns/day, 68.210 hours/ns, 4.072 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    | 244.99     | 244.99     | 244.99     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10299    | 0.10299    | 0.10299    |   0.0 |  0.04
Output  | 0.00057854 | 0.00057854 | 0.00057854 |   0.0 |  0.00
Modify  | 0.40034    | 0.40034    | 0.40034    |   0.0 |  0.16
Other   |            | 0.06198    |            |       |  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:      131584.0 ave      131584 max      131584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131584
Ave neighs/atom = 65.792000
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.568902466382, Press = -6.92673740969315
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8425.3169   -8425.3169   -8502.4659   -8502.4659    298.57442    298.57442    23399.863    23399.863   -1603.5294   -1603.5294 
   16000    -8424.053    -8424.053   -8499.7834   -8499.7834    293.08439    293.08439    23407.271    23407.271   -1883.4515   -1883.4515 
Loop time of 239.74 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.360 ns/day, 66.595 hours/ns, 4.171 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    | 239.2      | 239.2      | 239.2      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10064    | 0.10064    | 0.10064    |   0.0 |  0.04
Output  | 0.00015831 | 0.00015831 | 0.00015831 |   0.0 |  0.00
Modify  | 0.38242    | 0.38242    | 0.38242    |   0.0 |  0.16
Other   |            | 0.06076    |            |       |  0.03

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

Total # of neighbors = 131742
Ave neighs/atom = 65.871000
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.422238203479, Press = -5.88540599602842
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000    -8424.053    -8424.053   -8499.7834   -8499.7834    293.08439    293.08439    23407.271    23407.271   -1883.4515   -1883.4515 
   17000   -8428.1764   -8428.1764   -8502.5184   -8502.5184    287.71149    287.71149    23427.501    23427.501   -3696.7286   -3696.7286 
Loop time of 247.17 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.350 ns/day, 68.658 hours/ns, 4.046 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    | 246.61     | 246.61     | 246.61     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10396    | 0.10396    | 0.10396    |   0.0 |  0.04
Output  | 0.00021796 | 0.00021796 | 0.00021796 |   0.0 |  0.00
Modify  | 0.3983     | 0.3983     | 0.3983     |   0.0 |  0.16
Other   |            | 0.06245    |            |       |  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:      131940.0 ave      131940 max      131940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131940
Ave neighs/atom = 65.970000
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.501171707648, Press = -6.04286306067401
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8428.1764   -8428.1764   -8502.5184   -8502.5184    287.71149    287.71149    23427.501    23427.501   -3696.7286   -3696.7286 
   18000   -8423.7859   -8423.7859   -8500.5956   -8500.5956    297.26143    297.26143    23436.189    23436.189   -3897.2848   -3897.2848 
Loop time of 262.743 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.329 ns/day, 72.984 hours/ns, 3.806 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    | 262.13     | 262.13     | 262.13     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1093     | 0.1093     | 0.1093     |   0.0 |  0.04
Output  | 0.00015317 | 0.00015317 | 0.00015317 |   0.0 |  0.00
Modify  | 0.43802    | 0.43802    | 0.43802    |   0.0 |  0.17
Other   |            | 0.06468    |            |       |  0.02

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

Total # of neighbors = 131410
Ave neighs/atom = 65.705000
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.586713681123, Press = -2.32049910979145
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8423.7859   -8423.7859   -8500.5956   -8500.5956    297.26143    297.26143    23436.189    23436.189   -3897.2848   -3897.2848 
   19000   -8426.5837   -8426.5837   -8504.2406   -8504.2406    300.54036    300.54036    23398.294    23398.294    -1783.676    -1783.676 
Loop time of 237.194 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.364 ns/day, 65.887 hours/ns, 4.216 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    | 236.65     | 236.65     | 236.65     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10023    | 0.10023    | 0.10023    |   0.0 |  0.04
Output  | 0.00015314 | 0.00015314 | 0.00015314 |   0.0 |  0.00
Modify  | 0.37912    | 0.37912    | 0.37912    |   0.0 |  0.16
Other   |            | 0.06037    |            |       |  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:      131504.0 ave      131504 max      131504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131504
Ave neighs/atom = 65.752000
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.654540847879, Press = -2.40015819856192
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8426.5837   -8426.5837   -8504.2406   -8504.2406    300.54036    300.54036    23398.294    23398.294    -1783.676    -1783.676 
   20000   -8424.4639   -8424.4639   -8502.5786   -8502.5786    302.31219    302.31219    23397.509    23397.509   -1475.8438   -1475.8438 
Loop time of 238.711 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.362 ns/day, 66.309 hours/ns, 4.189 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    | 238.17     | 238.17     | 238.17     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10063    | 0.10063    | 0.10063    |   0.0 |  0.04
Output  | 0.00019056 | 0.00019056 | 0.00019056 |   0.0 |  0.00
Modify  | 0.38108    | 0.38108    | 0.38108    |   0.0 |  0.16
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:      131566.0 ave      131566 max      131566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131566
Ave neighs/atom = 65.783000
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.682540723863, Press = -0.749663711510596
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8424.4639   -8424.4639   -8502.5786   -8502.5786    302.31219    302.31219    23397.509    23397.509   -1475.8438   -1475.8438 
   21000   -8427.5477   -8427.5477   -8502.9809   -8502.9809    291.93418    291.93418    23384.762    23384.762   -719.30511   -719.30511 
Loop time of 261.243 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.567 hours/ns, 3.828 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.63     | 260.63     | 260.63     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10826    | 0.10826    | 0.10826    |   0.0 |  0.04
Output  | 0.00019475 | 0.00019475 | 0.00019475 |   0.0 |  0.00
Modify  | 0.43744    | 0.43744    | 0.43744    |   0.0 |  0.17
Other   |            | 0.06477    |            |       |  0.02

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

Total # of neighbors = 131654
Ave neighs/atom = 65.827000
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.718882370644, Press = -1.13109520773627
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8427.5477   -8427.5477   -8502.9809   -8502.9809    291.93418    291.93418    23384.762    23384.762   -719.30511   -719.30511 
   22000   -8425.1498   -8425.1498   -8500.7195   -8500.7195    292.46244    292.46244    23384.411    23384.411   -297.58263   -297.58263 
Loop time of 235.483 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.367 ns/day, 65.412 hours/ns, 4.247 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.95     | 234.95     | 234.95     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099388   | 0.099388   | 0.099388   |   0.0 |  0.04
Output  | 0.00015581 | 0.00015581 | 0.00015581 |   0.0 |  0.00
Modify  | 0.37473    | 0.37473    | 0.37473    |   0.0 |  0.16
Other   |            | 0.05906    |            |       |  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:      131632.0 ave      131632 max      131632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131632
Ave neighs/atom = 65.816000
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.625905939534, Press = 0.749322428044801
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8425.1498   -8425.1498   -8500.7195   -8500.7195    292.46244    292.46244    23384.411    23384.411   -297.58263   -297.58263 
   23000   -8424.9117   -8424.9117    -8499.281    -8499.281    287.81685    287.81685    23386.868    23386.868    -287.8275    -287.8275 
Loop time of 227.135 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.380 ns/day, 63.093 hours/ns, 4.403 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.63     | 226.63     | 226.63     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096412   | 0.096412   | 0.096412   |   0.0 |  0.04
Output  | 0.00015533 | 0.00015533 | 0.00015533 |   0.0 |  0.00
Modify  | 0.35251    | 0.35251    | 0.35251    |   0.0 |  0.16
Other   |            | 0.0577     |            |       |  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:      131846.0 ave      131846 max      131846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131846
Ave neighs/atom = 65.923000
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.625230347116, Press = 3.01502584840319
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8424.9117   -8424.9117    -8499.281    -8499.281    287.81685    287.81685    23386.868    23386.868    -287.8275    -287.8275 
   24000   -8430.8716   -8430.8716   -8503.9886   -8503.9886    282.97043    282.97043    23363.351    23363.351    505.47042    505.47042 
Loop time of 229.877 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.855 hours/ns, 4.350 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.36     | 229.36     | 229.36     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097109   | 0.097109   | 0.097109   |   0.0 |  0.04
Output  | 0.00019858 | 0.00019858 | 0.00019858 |   0.0 |  0.00
Modify  | 0.35972    | 0.35972    | 0.35972    |   0.0 |  0.16
Other   |            | 0.05814    |            |       |  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:      131800.0 ave      131800 max      131800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131800
Ave neighs/atom = 65.900000
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.464378392381, Press = 1.82559172153164
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8430.8716   -8430.8716   -8503.9886   -8503.9886    282.97043    282.97043    23363.351    23363.351    505.47042    505.47042 
   25000    -8426.409    -8426.409   -8501.1524   -8501.1524    289.26477    289.26477    23364.077    23364.077    1009.2265    1009.2265 
Loop time of 254.743 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.339 ns/day, 70.762 hours/ns, 3.926 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    | 254.15     | 254.15     | 254.15     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10612    | 0.10612    | 0.10612    |   0.0 |  0.04
Output  | 0.000156   | 0.000156   | 0.000156   |   0.0 |  0.00
Modify  | 0.42098    | 0.42098    | 0.42098    |   0.0 |  0.17
Other   |            | 0.06383    |            |       |  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:      131636.0 ave      131636 max      131636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131636
Ave neighs/atom = 65.818000
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.388962044634, Press = 0.190149700026198
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000    -8426.409    -8426.409   -8501.1524   -8501.1524    289.26477    289.26477    23364.077    23364.077    1009.2265    1009.2265 
   26000   -8427.5767   -8427.5767   -8501.9909   -8501.9909    287.99063    287.99063    23356.912    23356.912    1346.5462    1346.5462 
Loop time of 262.641 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.329 ns/day, 72.956 hours/ns, 3.807 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.03     | 262.03     | 262.03     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10792    | 0.10792    | 0.10792    |   0.0 |  0.04
Output  | 0.00015463 | 0.00015463 | 0.00015463 |   0.0 |  0.00
Modify  | 0.43909    | 0.43909    | 0.43909    |   0.0 |  0.17
Other   |            | 0.06411    |            |       |  0.02

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

Total # of neighbors = 131792
Ave neighs/atom = 65.896000
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.327595321775, Press = 0.331022258841984
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8427.5767   -8427.5767   -8501.9909   -8501.9909    287.99063    287.99063    23356.912    23356.912    1346.5462    1346.5462 
   27000   -8426.8057   -8426.8057   -8502.1177   -8502.1177    291.46504    291.46504    23349.226    23349.226    2001.4184    2001.4184 
Loop time of 263.099 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.328 ns/day, 73.083 hours/ns, 3.801 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.49     | 262.49     | 262.49     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10918    | 0.10918    | 0.10918    |   0.0 |  0.04
Output  | 0.00019522 | 0.00019522 | 0.00019522 |   0.0 |  0.00
Modify  | 0.43873    | 0.43873    | 0.43873    |   0.0 |  0.17
Other   |            | 0.06434    |            |       |  0.02

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

Total # of neighbors = 131946
Ave neighs/atom = 65.973000
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
23376.7911269089

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0