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

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

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

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

kim_interactions Li

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

kim interactions Li
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_RoyDuttaChakraborti_2021_AlLi__MO_971738391444_000
pair_coeff * * Li
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 6.941

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_971738391444_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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -3229.4205   -3229.4205        -3300        -3300       273.15       273.15    43206.602    43206.602    1744.8045    1744.8045 
    1000   -3213.0206   -3213.0206   -3282.9603   -3282.9603    270.67355    270.67355    47079.923    47079.923    268.72302    268.72302 
Loop time of 92.4648 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.934 ns/day, 25.685 hours/ns, 10.815 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    | 91.486     | 91.486     | 91.486     |   0.0 | 98.94
Neigh   | 0.48222    | 0.48222    | 0.48222    |   0.0 |  0.52
Comm    | 0.090283   | 0.090283   | 0.090283   |   0.0 |  0.10
Output  | 0.00023865 | 0.00023865 | 0.00023865 |   0.0 |  0.00
Modify  | 0.35169    | 0.35169    | 0.35169    |   0.0 |  0.38
Other   |            | 0.05458    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3241.00 ave        3241 max        3241 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:      119714.0 ave      119714 max      119714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119714
Ave neighs/atom = 59.857000
Neighbor list builds = 22
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -3213.0206   -3213.0206   -3282.9603   -3282.9603    270.67355    270.67355    47079.923    47079.923    268.72302    268.72302 
    2000   -3212.6159   -3212.6159   -3283.6421   -3283.6421    274.87882    274.87882    47174.684    47174.684    54.368942    54.368942 
Loop time of 92.1081 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.938 ns/day, 25.586 hours/ns, 10.857 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    | 91.149     | 91.149     | 91.149     |   0.0 | 98.96
Neigh   | 0.46211    | 0.46211    | 0.46211    |   0.0 |  0.50
Comm    | 0.091372   | 0.091372   | 0.091372   |   0.0 |  0.10
Output  | 0.00021189 | 0.00021189 | 0.00021189 |   0.0 |  0.00
Modify  | 0.3498     | 0.3498     | 0.3498     |   0.0 |  0.38
Other   |            | 0.05529    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3277.00 ave        3277 max        3277 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:      119640.0 ave      119640 max      119640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119640
Ave neighs/atom = 59.820000
Neighbor list builds = 21
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -3212.6159   -3212.6159   -3283.6421   -3283.6421    274.87882    274.87882    47174.684    47174.684    54.368942    54.368942 
    3000   -3211.7289   -3211.7289   -3281.5217   -3281.5217    270.10531    270.10531    47207.389    47207.389    81.705956    81.705956 
Loop time of 94.689 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.912 ns/day, 26.303 hours/ns, 10.561 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    | 93.713     | 93.713     | 93.713     |   0.0 | 98.97
Neigh   | 0.46225    | 0.46225    | 0.46225    |   0.0 |  0.49
Comm    | 0.09302    | 0.09302    | 0.09302    |   0.0 |  0.10
Output  | 0.00022853 | 0.00022853 | 0.00022853 |   0.0 |  0.00
Modify  | 0.36374    | 0.36374    | 0.36374    |   0.0 |  0.38
Other   |            | 0.05659    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3330.00 ave        3330 max        3330 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:      119606.0 ave      119606 max      119606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119606
Ave neighs/atom = 59.803000
Neighbor list builds = 21
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -3211.7289   -3211.7289   -3281.5217   -3281.5217    270.10531    270.10531    47207.389    47207.389    81.705956    81.705956 
    4000   -3211.1457   -3211.1457   -3281.7909   -3281.7909    273.40445    273.40445    47200.674    47200.674   -49.841195   -49.841195 
Loop time of 94.4097 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.915 ns/day, 26.225 hours/ns, 10.592 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    | 93.437     | 93.437     | 93.437     |   0.0 | 98.97
Neigh   | 0.46089    | 0.46089    | 0.46089    |   0.0 |  0.49
Comm    | 0.093425   | 0.093425   | 0.093425   |   0.0 |  0.10
Output  | 0.00018771 | 0.00018771 | 0.00018771 |   0.0 |  0.00
Modify  | 0.36159    | 0.36159    | 0.36159    |   0.0 |  0.38
Other   |            | 0.05609    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3289.00 ave        3289 max        3289 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:      119534.0 ave      119534 max      119534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119534
Ave neighs/atom = 59.767000
Neighbor list builds = 21
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -3211.1457   -3211.1457   -3281.7909   -3281.7909    273.40445    273.40445    47200.674    47200.674   -49.841195   -49.841195 
    5000   -3213.5756   -3213.5756    -3283.677    -3283.677    271.29987    271.29987    47148.553    47148.553    144.25412    144.25412 
Loop time of 96.5356 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.815 hours/ns, 10.359 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    | 95.528     | 95.528     | 95.528     |   0.0 | 98.96
Neigh   | 0.48248    | 0.48248    | 0.48248    |   0.0 |  0.50
Comm    | 0.094634   | 0.094634   | 0.094634   |   0.0 |  0.10
Output  | 0.00019992 | 0.00019992 | 0.00019992 |   0.0 |  0.00
Modify  | 0.37341    | 0.37341    | 0.37341    |   0.0 |  0.39
Other   |            | 0.05719    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3292.00 ave        3292 max        3292 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:      119678.0 ave      119678 max      119678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119678
Ave neighs/atom = 59.839000
Neighbor list builds = 22
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 = 267.343969258355, Press = 232.146531234732
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -3213.5756   -3213.5756    -3283.677    -3283.677    271.29987    271.29987    47148.553    47148.553    144.25412    144.25412 
    6000   -3210.9226   -3210.9226   -3282.5653   -3282.5653    277.26447    277.26447    47341.309    47341.309   -197.30369   -197.30369 
Loop time of 95.0067 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.909 ns/day, 26.391 hours/ns, 10.526 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    | 93.991     | 93.991     | 93.991     |   0.0 | 98.93
Neigh   | 0.4847     | 0.4847     | 0.4847     |   0.0 |  0.51
Comm    | 0.092701   | 0.092701   | 0.092701   |   0.0 |  0.10
Output  | 0.00015444 | 0.00015444 | 0.00015444 |   0.0 |  0.00
Modify  | 0.38235    | 0.38235    | 0.38235    |   0.0 |  0.40
Other   |            | 0.05623    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3271.00 ave        3271 max        3271 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:      119324.0 ave      119324 max      119324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119324
Ave neighs/atom = 59.662000
Neighbor list builds = 22
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 = 270.824935035304, Press = 27.1785049906569
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -3210.9226   -3210.9226   -3282.5653   -3282.5653    277.26447    277.26447    47341.309    47341.309   -197.30369   -197.30369 
    7000   -3214.3996   -3214.3996   -3284.0054   -3284.0054    269.38185    269.38185    47349.344    47349.344   -408.16004   -408.16004 
Loop time of 95.0333 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.909 ns/day, 26.398 hours/ns, 10.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    | 94.023     | 94.023     | 94.023     |   0.0 | 98.94
Neigh   | 0.4812     | 0.4812     | 0.4812     |   0.0 |  0.51
Comm    | 0.092379   | 0.092379   | 0.092379   |   0.0 |  0.10
Output  | 0.00015569 | 0.00015569 | 0.00015569 |   0.0 |  0.00
Modify  | 0.38094    | 0.38094    | 0.38094    |   0.0 |  0.40
Other   |            | 0.05577    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3266.00 ave        3266 max        3266 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:      119458.0 ave      119458 max      119458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119458
Ave neighs/atom = 59.729000
Neighbor list builds = 22
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 = 271.131831139859, Press = 10.9232776317635
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -3214.3996   -3214.3996   -3284.0054   -3284.0054    269.38185    269.38185    47349.344    47349.344   -408.16004   -408.16004 
    8000   -3215.5775   -3215.5775   -3286.5504   -3286.5504    274.67225    274.67225    47352.293    47352.293   -243.05811   -243.05811 
Loop time of 94.8558 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.911 ns/day, 26.349 hours/ns, 10.542 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    | 93.851     | 93.851     | 93.851     |   0.0 | 98.94
Neigh   | 0.47417    | 0.47417    | 0.47417    |   0.0 |  0.50
Comm    | 0.092217   | 0.092217   | 0.092217   |   0.0 |  0.10
Output  | 0.00015562 | 0.00015562 | 0.00015562 |   0.0 |  0.00
Modify  | 0.38259    | 0.38259    | 0.38259    |   0.0 |  0.40
Other   |            | 0.05587    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3307.00 ave        3307 max        3307 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:      119176.0 ave      119176 max      119176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119176
Ave neighs/atom = 59.588000
Neighbor list builds = 22
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 = 271.560629245556, Press = -9.64512902064405
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -3215.5775   -3215.5775   -3286.5504   -3286.5504    274.67225    274.67225    47352.293    47352.293   -243.05811   -243.05811 
    9000    -3213.961    -3213.961   -3285.8227   -3285.8227    278.11205    278.11205    46973.088    46973.088    562.38295    562.38295 
Loop time of 96.5197 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.811 hours/ns, 10.361 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    | 95.503     | 95.503     | 95.503     |   0.0 | 98.95
Neigh   | 0.47646    | 0.47646    | 0.47646    |   0.0 |  0.49
Comm    | 0.094597   | 0.094597   | 0.094597   |   0.0 |  0.10
Output  | 0.00015375 | 0.00015375 | 0.00015375 |   0.0 |  0.00
Modify  | 0.38883    | 0.38883    | 0.38883    |   0.0 |  0.40
Other   |            | 0.05712    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3292.00 ave        3292 max        3292 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:      119850.0 ave      119850 max      119850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119850
Ave neighs/atom = 59.925000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.057724592856, Press = 2.81594071465619
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000    -3213.961    -3213.961   -3285.8227   -3285.8227    278.11205    278.11205    46973.088    46973.088    562.38295    562.38295 
   10000   -3214.0915   -3214.0915   -3284.1985   -3284.1985    271.32141    271.32141    47159.823    47159.823    97.828927    97.828927 
Loop time of 97.3959 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.054 hours/ns, 10.267 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    | 96.387     | 96.387     | 96.387     |   0.0 | 98.96
Neigh   | 0.45883    | 0.45883    | 0.45883    |   0.0 |  0.47
Comm    | 0.094861   | 0.094861   | 0.094861   |   0.0 |  0.10
Output  | 0.00015518 | 0.00015518 | 0.00015518 |   0.0 |  0.00
Modify  | 0.39807    | 0.39807    | 0.39807    |   0.0 |  0.41
Other   |            | 0.05721    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3338.00 ave        3338 max        3338 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:      119894.0 ave      119894 max      119894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119894
Ave neighs/atom = 59.947000
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.399563025912, Press = 6.00701907371161
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -3214.0915   -3214.0915   -3284.1985   -3284.1985    271.32141    271.32141    47159.823    47159.823    97.828927    97.828927 
   11000    -3215.052    -3215.052   -3285.9473   -3285.9473    274.37235    274.37235    47276.735    47276.735   -68.988203   -68.988203 
Loop time of 95.102 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.908 ns/day, 26.417 hours/ns, 10.515 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    | 94.093     | 94.093     | 94.093     |   0.0 | 98.94
Neigh   | 0.47282    | 0.47282    | 0.47282    |   0.0 |  0.50
Comm    | 0.093198   | 0.093198   | 0.093198   |   0.0 |  0.10
Output  | 0.0001555  | 0.0001555  | 0.0001555  |   0.0 |  0.00
Modify  | 0.38628    | 0.38628    | 0.38628    |   0.0 |  0.41
Other   |            | 0.05645    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3280.00 ave        3280 max        3280 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:      119454.0 ave      119454 max      119454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119454
Ave neighs/atom = 59.727000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.323465192292, Press = 1.78283866891135
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000    -3215.052    -3215.052   -3285.9473   -3285.9473    274.37235    274.37235    47276.735    47276.735   -68.988203   -68.988203 
   12000   -3212.2006   -3212.2006   -3285.2086   -3285.2086    282.54849    282.54849    47195.467    47195.467    101.65593    101.65593 
Loop time of 96.1911 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.720 hours/ns, 10.396 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    | 95.179     | 95.179     | 95.179     |   0.0 | 98.95
Neigh   | 0.47705    | 0.47705    | 0.47705    |   0.0 |  0.50
Comm    | 0.093076   | 0.093076   | 0.093076   |   0.0 |  0.10
Output  | 0.00015137 | 0.00015137 | 0.00015137 |   0.0 |  0.00
Modify  | 0.3851     | 0.3851     | 0.3851     |   0.0 |  0.40
Other   |            | 0.05648    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3329.00 ave        3329 max        3329 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:      119840.0 ave      119840 max      119840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119840
Ave neighs/atom = 59.920000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.316198027763, Press = 1.40384099665
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -3212.2006   -3212.2006   -3285.2086   -3285.2086    282.54849    282.54849    47195.467    47195.467    101.65593    101.65593 
   13000     -3217.34     -3217.34   -3289.1313   -3289.1313    277.83971    277.83971    47213.799    47213.799    141.56209    141.56209 
Loop time of 96.9936 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.891 ns/day, 26.943 hours/ns, 10.310 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    | 95.979     | 95.979     | 95.979     |   0.0 | 98.95
Neigh   | 0.47521    | 0.47521    | 0.47521    |   0.0 |  0.49
Comm    | 0.093569   | 0.093569   | 0.093569   |   0.0 |  0.10
Output  | 0.00015373 | 0.00015373 | 0.00015373 |   0.0 |  0.00
Modify  | 0.38953    | 0.38953    | 0.38953    |   0.0 |  0.40
Other   |            | 0.05647    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3315.00 ave        3315 max        3315 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:      119468.0 ave      119468 max      119468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119468
Ave neighs/atom = 59.734000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.63899051544, Press = 2.72373256208746
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000     -3217.34     -3217.34   -3289.1313   -3289.1313    277.83971    277.83971    47213.799    47213.799    141.56209    141.56209 
   14000    -3216.281    -3216.281   -3288.0717   -3288.0717    277.83769    277.83769    47294.745    47294.745   -70.129711   -70.129711 
Loop time of 99.1051 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.529 hours/ns, 10.090 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    | 98.079     | 98.079     | 98.079     |   0.0 | 98.97
Neigh   | 0.47465    | 0.47465    | 0.47465    |   0.0 |  0.48
Comm    | 0.094734   | 0.094734   | 0.094734   |   0.0 |  0.10
Output  | 0.00015333 | 0.00015333 | 0.00015333 |   0.0 |  0.00
Modify  | 0.39849    | 0.39849    | 0.39849    |   0.0 |  0.40
Other   |            | 0.0577     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3335.00 ave        3335 max        3335 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:      119152.0 ave      119152 max      119152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119152
Ave neighs/atom = 59.576000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.941246598636, Press = 1.10927910404588
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000    -3216.281    -3216.281   -3288.0717   -3288.0717    277.83769    277.83769    47294.745    47294.745   -70.129711   -70.129711 
   15000   -3214.7377   -3214.7377   -3285.7768   -3285.7768    274.92845    274.92845     47432.57     47432.57   -357.47447   -357.47447 
Loop time of 95.6178 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.904 ns/day, 26.561 hours/ns, 10.458 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    | 94.611     | 94.611     | 94.611     |   0.0 | 98.95
Neigh   | 0.47619    | 0.47619    | 0.47619    |   0.0 |  0.50
Comm    | 0.093191   | 0.093191   | 0.093191   |   0.0 |  0.10
Output  | 0.00015319 | 0.00015319 | 0.00015319 |   0.0 |  0.00
Modify  | 0.38101    | 0.38101    | 0.38101    |   0.0 |  0.40
Other   |            | 0.0562     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3308.00 ave        3308 max        3308 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:      119290.0 ave      119290 max      119290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119290
Ave neighs/atom = 59.645000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.775146471988, Press = -2.00079115217981
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -3214.7377   -3214.7377   -3285.7768   -3285.7768    274.92845    274.92845     47432.57     47432.57   -357.47447   -357.47447 
   16000   -3218.1894   -3218.1894   -3288.7098   -3288.7098    272.92151    272.92151    46903.176    46903.176    857.69754    857.69754 
Loop time of 97.3976 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.055 hours/ns, 10.267 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    | 96.385     | 96.385     | 96.385     |   0.0 | 98.96
Neigh   | 0.4739     | 0.4739     | 0.4739     |   0.0 |  0.49
Comm    | 0.094117   | 0.094117   | 0.094117   |   0.0 |  0.10
Output  | 0.00021832 | 0.00021832 | 0.00021832 |   0.0 |  0.00
Modify  | 0.38822    | 0.38822    | 0.38822    |   0.0 |  0.40
Other   |            | 0.056      |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3331.00 ave        3331 max        3331 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:      120022.0 ave      120022 max      120022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120022
Ave neighs/atom = 60.011000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.612299035761, Press = -1.42722156995233
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -3218.1894   -3218.1894   -3288.7098   -3288.7098    272.92151    272.92151    46903.176    46903.176    857.69754    857.69754 
   17000   -3219.0483   -3219.0483    -3287.338    -3287.338    264.28818    264.28818     47127.82     47127.82    170.85603    170.85603 
Loop time of 98.0006 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.222 hours/ns, 10.204 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    | 96.997     | 96.997     | 96.997     |   0.0 | 98.98
Neigh   | 0.46111    | 0.46111    | 0.46111    |   0.0 |  0.47
Comm    | 0.094919   | 0.094919   | 0.094919   |   0.0 |  0.10
Output  | 0.00015433 | 0.00015433 | 0.00015433 |   0.0 |  0.00
Modify  | 0.39055    | 0.39055    | 0.39055    |   0.0 |  0.40
Other   |            | 0.05721    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3338.00 ave        3338 max        3338 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:      119790.0 ave      119790 max      119790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119790
Ave neighs/atom = 59.895000
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.58578016508, Press = 2.75258062991291
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -3219.0483   -3219.0483    -3287.338    -3287.338    264.28818    264.28818     47127.82     47127.82    170.85603    170.85603 
   18000   -3216.9638   -3216.9638   -3287.9512   -3287.9512    274.72873    274.72873    47436.542    47436.542   -329.67287   -329.67287 
Loop time of 100.345 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.861 ns/day, 27.874 hours/ns, 9.966 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    | 99.308     | 99.308     | 99.308     |   0.0 | 98.97
Neigh   | 0.48409    | 0.48409    | 0.48409    |   0.0 |  0.48
Comm    | 0.094941   | 0.094941   | 0.094941   |   0.0 |  0.09
Output  | 0.0002133  | 0.0002133  | 0.0002133  |   0.0 |  0.00
Modify  | 0.4007     | 0.4007     | 0.4007     |   0.0 |  0.40
Other   |            | 0.05731    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3356.00 ave        3356 max        3356 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:      119102.0 ave      119102 max      119102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119102
Ave neighs/atom = 59.551000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.582921679041, Press = 1.79975940462095
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -3216.9638   -3216.9638   -3287.9512   -3287.9512    274.72873    274.72873    47436.542    47436.542   -329.67287   -329.67287 
   19000   -3217.2411   -3217.2411    -3287.897    -3287.897    273.44546    273.44546    47313.719    47313.719   -192.99305   -192.99305 
Loop time of 99.2412 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.567 hours/ns, 10.076 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    | 98.206     | 98.206     | 98.206     |   0.0 | 98.96
Neigh   | 0.48212    | 0.48212    | 0.48212    |   0.0 |  0.49
Comm    | 0.096288   | 0.096288   | 0.096288   |   0.0 |  0.10
Output  | 0.00024049 | 0.00024049 | 0.00024049 |   0.0 |  0.00
Modify  | 0.3997     | 0.3997     | 0.3997     |   0.0 |  0.40
Other   |            | 0.05727    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3330.00 ave        3330 max        3330 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:      119334.0 ave      119334 max      119334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119334
Ave neighs/atom = 59.667000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.454723999999, Press = 1.25513697437954
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -3217.2411   -3217.2411    -3287.897    -3287.897    273.44546    273.44546    47313.719    47313.719   -192.99305   -192.99305 
   20000   -3218.2572   -3218.2572   -3287.1953   -3287.1953    266.79723    266.79723    47129.125    47129.125    258.60814    258.60814 
Loop time of 96.8079 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.891 hours/ns, 10.330 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    | 95.818     | 95.818     | 95.818     |   0.0 | 98.98
Neigh   | 0.4521     | 0.4521     | 0.4521     |   0.0 |  0.47
Comm    | 0.093891   | 0.093891   | 0.093891   |   0.0 |  0.10
Output  | 0.00019505 | 0.00019505 | 0.00019505 |   0.0 |  0.00
Modify  | 0.38655    | 0.38655    | 0.38655    |   0.0 |  0.40
Other   |            | 0.05681    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3335.00 ave        3335 max        3335 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:      119506.0 ave      119506 max      119506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119506
Ave neighs/atom = 59.753000
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.528678621693, Press = -1.11834511117151
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -3218.2572   -3218.2572   -3287.1953   -3287.1953    266.79723    266.79723    47129.125    47129.125    258.60814    258.60814 
   21000   -3217.1207   -3217.1207   -3286.1683   -3286.1683    267.22113    267.22113    47144.889    47144.889    198.19338    198.19338 
Loop time of 97.8974 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.194 hours/ns, 10.215 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    | 96.904     | 96.904     | 96.904     |   0.0 | 98.99
Neigh   | 0.45223    | 0.45223    | 0.45223    |   0.0 |  0.46
Comm    | 0.094017   | 0.094017   | 0.094017   |   0.0 |  0.10
Output  | 0.00019374 | 0.00019374 | 0.00019374 |   0.0 |  0.00
Modify  | 0.38982    | 0.38982    | 0.38982    |   0.0 |  0.40
Other   |            | 0.05674    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3320.00 ave        3320 max        3320 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:      119606.0 ave      119606 max      119606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119606
Ave neighs/atom = 59.803000
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.552906290757, Press = 2.45371606876736
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -3217.1207   -3217.1207   -3286.1683   -3286.1683    267.22113    267.22113    47144.889    47144.889    198.19338    198.19338 
   22000   -3218.5834   -3218.5834   -3288.6858   -3288.6858    271.30365    271.30365    47357.103    47357.103   -277.35392   -277.35392 
Loop time of 97.3109 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.888 ns/day, 27.031 hours/ns, 10.276 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    | 96.32      | 96.32      | 96.32      |   0.0 | 98.98
Neigh   | 0.45015    | 0.45015    | 0.45015    |   0.0 |  0.46
Comm    | 0.093327   | 0.093327   | 0.093327   |   0.0 |  0.10
Output  | 0.00016675 | 0.00016675 | 0.00016675 |   0.0 |  0.00
Modify  | 0.3899     | 0.3899     | 0.3899     |   0.0 |  0.40
Other   |            | 0.05758    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3354.00 ave        3354 max        3354 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:      119356.0 ave      119356 max      119356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119356
Ave neighs/atom = 59.678000
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.592784668806, Press = 0.426672478421753
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -3218.5834   -3218.5834   -3288.6858   -3288.6858    271.30365    271.30365    47357.103    47357.103   -277.35392   -277.35392 
   23000   -3215.9731   -3215.9731   -3287.1299   -3287.1299    275.38403    275.38403    47234.428    47234.428    158.08133    158.08133 
Loop time of 99.2052 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.557 hours/ns, 10.080 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    | 98.183     | 98.183     | 98.183     |   0.0 | 98.97
Neigh   | 0.47156    | 0.47156    | 0.47156    |   0.0 |  0.48
Comm    | 0.095044   | 0.095044   | 0.095044   |   0.0 |  0.10
Output  | 0.00015461 | 0.00015461 | 0.00015461 |   0.0 |  0.00
Modify  | 0.39747    | 0.39747    | 0.39747    |   0.0 |  0.40
Other   |            | 0.05764    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3321.00 ave        3321 max        3321 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:      119614.0 ave      119614 max      119614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119614
Ave neighs/atom = 59.807000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.64469868917, Press = -0.305078688221381
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -3215.9731   -3215.9731   -3287.1299   -3287.1299    275.38403    275.38403    47234.428    47234.428    158.08133    158.08133 
   24000   -3214.1876   -3214.1876   -3287.0837   -3287.0837     282.1155     282.1155    47170.336    47170.336    188.51772    188.51772 
Loop time of 96.4432 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.790 hours/ns, 10.369 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    | 95.428     | 95.428     | 95.428     |   0.0 | 98.95
Neigh   | 0.48354    | 0.48354    | 0.48354    |   0.0 |  0.50
Comm    | 0.092947   | 0.092947   | 0.092947   |   0.0 |  0.10
Output  | 0.00015564 | 0.00015564 | 0.00015564 |   0.0 |  0.00
Modify  | 0.38189    | 0.38189    | 0.38189    |   0.0 |  0.40
Other   |            | 0.05618    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3326.00 ave        3326 max        3326 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:      119704.0 ave      119704 max      119704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119704
Ave neighs/atom = 59.852000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.733736404328, Press = 1.73435042012427
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -3214.1876   -3214.1876   -3287.0837   -3287.0837     282.1155     282.1155    47170.336    47170.336    188.51772    188.51772 
   25000   -3217.5083   -3217.5083   -3287.8352   -3287.8352    272.17247    272.17247    47338.257    47338.257   -189.69947   -189.69947 
Loop time of 96.9422 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.891 ns/day, 26.928 hours/ns, 10.315 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    | 95.93      | 95.93      | 95.93      |   0.0 | 98.96
Neigh   | 0.47463    | 0.47463    | 0.47463    |   0.0 |  0.49
Comm    | 0.094473   | 0.094473   | 0.094473   |   0.0 |  0.10
Output  | 0.00015394 | 0.00015394 | 0.00015394 |   0.0 |  0.00
Modify  | 0.38612    | 0.38612    | 0.38612    |   0.0 |  0.40
Other   |            | 0.05647    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3340.00 ave        3340 max        3340 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:      119228.0 ave      119228 max      119228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119228
Ave neighs/atom = 59.614000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.881760112867, Press = 0.830845155773855
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -3217.5083   -3217.5083   -3287.8352   -3287.8352    272.17247    272.17247    47338.257    47338.257   -189.69947   -189.69947 
   26000   -3217.9418   -3217.9418   -3289.3155   -3289.3155    276.22343    276.22343    47406.762    47406.762   -379.45953   -379.45953 
Loop time of 99.1693 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.547 hours/ns, 10.084 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    | 98.138     | 98.138     | 98.138     |   0.0 | 98.96
Neigh   | 0.48283    | 0.48283    | 0.48283    |   0.0 |  0.49
Comm    | 0.095453   | 0.095453   | 0.095453   |   0.0 |  0.10
Output  | 0.00015291 | 0.00015291 | 0.00015291 |   0.0 |  0.00
Modify  | 0.39538    | 0.39538    | 0.39538    |   0.0 |  0.40
Other   |            | 0.05717    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3335.00 ave        3335 max        3335 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:      119386.0 ave      119386 max      119386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119386
Ave neighs/atom = 59.693000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.9249451082, Press = -0.909722239321575
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -3217.9418   -3217.9418   -3289.3155   -3289.3155    276.22343    276.22343    47406.762    47406.762   -379.45953   -379.45953 
   27000   -3220.2693   -3220.2693   -3289.8614   -3289.8614     269.3285     269.3285    46981.822    46981.822     593.7453     593.7453 
Loop time of 96.4759 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.799 hours/ns, 10.365 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    | 95.474     | 95.474     | 95.474     |   0.0 | 98.96
Neigh   | 0.47103    | 0.47103    | 0.47103    |   0.0 |  0.49
Comm    | 0.092361   | 0.092361   | 0.092361   |   0.0 |  0.10
Output  | 0.00015308 | 0.00015308 | 0.00015308 |   0.0 |  0.00
Modify  | 0.38178    | 0.38178    | 0.38178    |   0.0 |  0.40
Other   |            | 0.0563     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3371.00 ave        3371 max        3371 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:      119672.0 ave      119672 max      119672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119672
Ave neighs/atom = 59.836000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.914693601842, Press = -0.476489500447734
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -3220.2693   -3220.2693   -3289.8614   -3289.8614     269.3285     269.3285    46981.822    46981.822     593.7453     593.7453 
   28000   -3216.7007   -3216.7007   -3287.7378   -3287.7378    274.92077    274.92077     47183.26     47183.26    244.20925    244.20925 
Loop time of 95.8573 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.627 hours/ns, 10.432 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    | 94.864     | 94.864     | 94.864     |   0.0 | 98.96
Neigh   | 0.46703    | 0.46703    | 0.46703    |   0.0 |  0.49
Comm    | 0.092079   | 0.092079   | 0.092079   |   0.0 |  0.10
Output  | 0.00015421 | 0.00015421 | 0.00015421 |   0.0 |  0.00
Modify  | 0.37767    | 0.37767    | 0.37767    |   0.0 |  0.39
Other   |            | 0.05605    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3313.00 ave        3313 max        3313 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:      119552.0 ave      119552 max      119552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119552
Ave neighs/atom = 59.776000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.858262571612, Press = 1.96046954008019
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -3216.7007   -3216.7007   -3287.7378   -3287.7378    274.92077    274.92077     47183.26     47183.26    244.20925    244.20925 
   29000   -3218.1901   -3218.1901   -3289.3009   -3289.3009    275.20641    275.20641    47242.354    47242.354    11.844761    11.844761 
Loop time of 96.426 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.785 hours/ns, 10.371 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.428     | 95.428     | 95.428     |   0.0 | 98.96
Neigh   | 0.4718     | 0.4718     | 0.4718     |   0.0 |  0.49
Comm    | 0.092699   | 0.092699   | 0.092699   |   0.0 |  0.10
Output  | 0.00030127 | 0.00030127 | 0.00030127 |   0.0 |  0.00
Modify  | 0.37825    | 0.37825    | 0.37825    |   0.0 |  0.39
Other   |            | 0.05531    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3347.00 ave        3347 max        3347 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:      119732.0 ave      119732 max      119732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119732
Ave neighs/atom = 59.866000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.859325571592, Press = 1.23954571963842
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -3218.1901   -3218.1901   -3289.3009   -3289.3009    275.20641    275.20641    47242.354    47242.354    11.844761    11.844761 
   30000   -3217.8478   -3217.8478   -3286.5199   -3286.5199     265.7684     265.7684    47285.473    47285.473   -250.93798   -250.93798 
Loop time of 97.6149 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.885 ns/day, 27.115 hours/ns, 10.244 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    | 96.623     | 96.623     | 96.623     |   0.0 | 98.98
Neigh   | 0.4538     | 0.4538     | 0.4538     |   0.0 |  0.46
Comm    | 0.093149   | 0.093149   | 0.093149   |   0.0 |  0.10
Output  | 0.00022522 | 0.00022522 | 0.00022522 |   0.0 |  0.00
Modify  | 0.38842    | 0.38842    | 0.38842    |   0.0 |  0.40
Other   |            | 0.05675    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3313.00 ave        3313 max        3313 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:      119680.0 ave      119680 max      119680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119680
Ave neighs/atom = 59.840000
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.968615065462, Press = 0.39369977348402
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -3217.8478   -3217.8478   -3286.5199   -3286.5199     265.7684     265.7684    47285.473    47285.473   -250.93798   -250.93798 
   31000     -3215.84     -3215.84   -3287.5893   -3287.5893    277.67729    277.67729    47112.248    47112.248    333.48331    333.48331 
Loop time of 96.1206 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.700 hours/ns, 10.404 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    | 95.112     | 95.112     | 95.112     |   0.0 | 98.95
Neigh   | 0.47747    | 0.47747    | 0.47747    |   0.0 |  0.50
Comm    | 0.092956   | 0.092956   | 0.092956   |   0.0 |  0.10
Output  | 0.00018616 | 0.00018616 | 0.00018616 |   0.0 |  0.00
Modify  | 0.38107    | 0.38107    | 0.38107    |   0.0 |  0.40
Other   |            | 0.05654    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3339.00 ave        3339 max        3339 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:      119818.0 ave      119818 max      119818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119818
Ave neighs/atom = 59.909000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.984101512933, Press = 0.684687582584166
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000     -3215.84     -3215.84   -3287.5893   -3287.5893    277.67729    277.67729    47112.248    47112.248    333.48331    333.48331 
   32000   -3214.1188   -3214.1188   -3285.1457   -3285.1457    274.88164    274.88164    47460.403    47460.403   -386.29096   -386.29096 
Loop time of 96.2549 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.737 hours/ns, 10.389 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    | 95.248     | 95.248     | 95.248     |   0.0 | 98.95
Neigh   | 0.47749    | 0.47749    | 0.47749    |   0.0 |  0.50
Comm    | 0.093102   | 0.093102   | 0.093102   |   0.0 |  0.10
Output  | 0.00021158 | 0.00021158 | 0.00021158 |   0.0 |  0.00
Modify  | 0.3806     | 0.3806     | 0.3806     |   0.0 |  0.40
Other   |            | 0.05591    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3335.00 ave        3335 max        3335 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:      119500.0 ave      119500 max      119500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119500
Ave neighs/atom = 59.750000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.995075005008, Press = 1.68388550545099
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -3214.1188   -3214.1188   -3285.1457   -3285.1457    274.88164    274.88164    47460.403    47460.403   -386.29096   -386.29096 
   33000   -3218.0914   -3218.0914   -3287.3531   -3287.3531    268.04996    268.04996    47362.056    47362.056   -242.64737   -242.64737 
Loop time of 97.5227 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.886 ns/day, 27.090 hours/ns, 10.254 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    | 96.486     | 96.486     | 96.486     |   0.0 | 98.94
Neigh   | 0.49477    | 0.49477    | 0.49477    |   0.0 |  0.51
Comm    | 0.094097   | 0.094097   | 0.094097   |   0.0 |  0.10
Output  | 0.00018661 | 0.00018661 | 0.00018661 |   0.0 |  0.00
Modify  | 0.39137    | 0.39137    | 0.39137    |   0.0 |  0.40
Other   |            | 0.05608    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3317.00 ave        3317 max        3317 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:      119216.0 ave      119216 max      119216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119216
Ave neighs/atom = 59.608000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.079328385614, Press = -0.628696593555145
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -3218.0914   -3218.0914   -3287.3531   -3287.3531    268.04996    268.04996    47362.056    47362.056   -242.64737   -242.64737 
   34000   -3215.4085   -3215.4085   -3287.9181   -3287.9181    280.61967    280.61967    47153.044    47153.044    110.78137    110.78137 
Loop time of 96.9264 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.891 ns/day, 26.924 hours/ns, 10.317 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    | 95.917     | 95.917     | 95.917     |   0.0 | 98.96
Neigh   | 0.47584    | 0.47584    | 0.47584    |   0.0 |  0.49
Comm    | 0.093574   | 0.093574   | 0.093574   |   0.0 |  0.10
Output  | 0.00015654 | 0.00015654 | 0.00015654 |   0.0 |  0.00
Modify  | 0.38423    | 0.38423    | 0.38423    |   0.0 |  0.40
Other   |            | 0.05585    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3316.00 ave        3316 max        3316 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:      119718.0 ave      119718 max      119718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119718
Ave neighs/atom = 59.859000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.144251343706, Press = 0.342535619247253
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -3215.4085   -3215.4085   -3287.9181   -3287.9181    280.61967    280.61967    47153.044    47153.044    110.78137    110.78137 
   35000   -3215.5799   -3215.5799   -3287.0379   -3287.0379    276.55008    276.55008    47317.441    47317.441   -161.37843   -161.37843 
Loop time of 94.9177 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.910 ns/day, 26.366 hours/ns, 10.535 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    | 93.946     | 93.946     | 93.946     |   0.0 | 98.98
Neigh   | 0.45102    | 0.45102    | 0.45102    |   0.0 |  0.48
Comm    | 0.090976   | 0.090976   | 0.090976   |   0.0 |  0.10
Output  | 0.00015186 | 0.00015186 | 0.00015186 |   0.0 |  0.00
Modify  | 0.37405    | 0.37405    | 0.37405    |   0.0 |  0.39
Other   |            | 0.05535    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3328.00 ave        3328 max        3328 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:      119654.0 ave      119654 max      119654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119654
Ave neighs/atom = 59.827000
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.162481094103, Press = 1.06566986344998
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -3215.5799   -3215.5799   -3287.0379   -3287.0379    276.55008    276.55008    47317.441    47317.441   -161.37843   -161.37843 
   36000   -3218.1818   -3218.1818   -3289.5258   -3289.5258    276.10867    276.10867    47325.666    47325.666   -157.96248   -157.96248 
Loop time of 95.918 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.644 hours/ns, 10.426 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    | 94.921     | 94.921     | 94.921     |   0.0 | 98.96
Neigh   | 0.47036    | 0.47036    | 0.47036    |   0.0 |  0.49
Comm    | 0.092953   | 0.092953   | 0.092953   |   0.0 |  0.10
Output  | 0.00015376 | 0.00015376 | 0.00015376 |   0.0 |  0.00
Modify  | 0.3772     | 0.3772     | 0.3772     |   0.0 |  0.39
Other   |            | 0.0563     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3305.00 ave        3305 max        3305 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:      119338.0 ave      119338 max      119338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119338
Ave neighs/atom = 59.669000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.174687876778, Press = 0.250960304303841
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -3218.1818   -3218.1818   -3289.5258   -3289.5258    276.10867    276.10867    47325.666    47325.666   -157.96248   -157.96248 
   37000   -3215.4113   -3215.4113   -3286.0349   -3286.0349    273.32072    273.32072    47212.694    47212.694    87.501695    87.501695 
Loop time of 96.5009 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.806 hours/ns, 10.363 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    | 95.494     | 95.494     | 95.494     |   0.0 | 98.96
Neigh   | 0.47354    | 0.47354    | 0.47354    |   0.0 |  0.49
Comm    | 0.093489   | 0.093489   | 0.093489   |   0.0 |  0.10
Output  | 0.00015658 | 0.00015658 | 0.00015658 |   0.0 |  0.00
Modify  | 0.38378    | 0.38378    | 0.38378    |   0.0 |  0.40
Other   |            | 0.05623    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3333.00 ave        3333 max        3333 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:      119770.0 ave      119770 max      119770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119770
Ave neighs/atom = 59.885000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.245608747194, Press = -0.337508823210924
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -3215.4113   -3215.4113   -3286.0349   -3286.0349    273.32072    273.32072    47212.694    47212.694    87.501695    87.501695 
   38000   -3213.8317   -3213.8317   -3286.2025   -3286.2025    280.08276    280.08276    47138.383    47138.383    396.47066    396.47066 
Loop time of 95.9969 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.666 hours/ns, 10.417 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    | 94.975     | 94.975     | 94.975     |   0.0 | 98.94
Neigh   | 0.49485    | 0.49485    | 0.49485    |   0.0 |  0.52
Comm    | 0.092662   | 0.092662   | 0.092662   |   0.0 |  0.10
Output  | 0.00015317 | 0.00015317 | 0.00015317 |   0.0 |  0.00
Modify  | 0.37842    | 0.37842    | 0.37842    |   0.0 |  0.39
Other   |            | 0.05627    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3321.00 ave        3321 max        3321 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:      119920.0 ave      119920 max      119920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119920
Ave neighs/atom = 59.960000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.268526442361, Press = 1.61108830684709
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -3213.8317   -3213.8317   -3286.2025   -3286.2025    280.08276    280.08276    47138.383    47138.383    396.47066    396.47066 
   39000    -3217.215    -3217.215   -3287.7939   -3287.7939    273.14794    273.14794    47511.371    47511.371   -485.00007   -485.00007 
Loop time of 96.2386 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.733 hours/ns, 10.391 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    | 95.234     | 95.234     | 95.234     |   0.0 | 98.96
Neigh   | 0.47285    | 0.47285    | 0.47285    |   0.0 |  0.49
Comm    | 0.092991   | 0.092991   | 0.092991   |   0.0 |  0.10
Output  | 0.00015379 | 0.00015379 | 0.00015379 |   0.0 |  0.00
Modify  | 0.38198    | 0.38198    | 0.38198    |   0.0 |  0.40
Other   |            | 0.05632    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3310.00 ave        3310 max        3310 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:      119002.0 ave      119002 max      119002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119002
Ave neighs/atom = 59.501000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.269590877617, Press = 0.584503877606958
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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000    -3217.215    -3217.215   -3287.7939   -3287.7939    273.14794    273.14794    47511.371    47511.371   -485.00007   -485.00007 
   40000   -3217.2599   -3217.2599   -3288.3808   -3288.3808    275.24513    275.24513    47232.614    47232.614    138.41807    138.41807 
Loop time of 95.5683 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.904 ns/day, 26.547 hours/ns, 10.464 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    | 94.595     | 94.595     | 94.595     |   0.0 | 98.98
Neigh   | 0.44703    | 0.44703    | 0.44703    |   0.0 |  0.47
Comm    | 0.0913     | 0.0913     | 0.0913     |   0.0 |  0.10
Output  | 0.0001843  | 0.0001843  | 0.0001843  |   0.0 |  0.00
Modify  | 0.37839    | 0.37839    | 0.37839    |   0.0 |  0.40
Other   |            | 0.05625    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3344.00 ave        3344 max        3344 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:      119444.0 ave      119444 max      119444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0