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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 2.850243076682091*${_u_distance}
variable latticeconst_converted equal 2.850243076682091*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85024307668209
Lattice spacing in x,y,z = 2.8502431 2.8502431 2.8502431
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.502431 28.502431 28.502431)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.502431 28.502431 28.502431)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_304347095149_000#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8499.7626   -8499.7626   -8580.6777   -8580.6777       313.15       313.15    23155.049    23155.049    3732.5262    3732.5262 
    1000   -8415.5519   -8415.5519   -8496.4054   -8496.4054    312.91137    312.91137    23387.703    23387.703    227.59439    227.59439 
Loop time of 245.553 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.352 ns/day, 68.209 hours/ns, 4.072 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    | 245        | 245        | 245        |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10219    | 0.10219    | 0.10219    |   0.0 |  0.04
Output  | 0.00020396 | 0.00020396 | 0.00020396 |   0.0 |  0.00
Modify  | 0.38183    | 0.38183    | 0.38183    |   0.0 |  0.16
Other   |            | 0.06397    |            |       |  0.03

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

Total # of neighbors = 128000
Ave neighs/atom = 64.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8415.5519   -8415.5519   -8496.4054   -8496.4054    312.91137    312.91137    23387.703    23387.703    227.59439    227.59439 
    2000   -8415.3266   -8415.3266   -8494.5896   -8494.5896     306.7557     306.7557    23419.683    23419.683   -1830.8253   -1830.8253 
Loop time of 225.697 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.383 ns/day, 62.694 hours/ns, 4.431 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    | 225.21     | 225.21     | 225.21     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094623   | 0.094623   | 0.094623   |   0.0 |  0.04
Output  | 0.0001966  | 0.0001966  | 0.0001966  |   0.0 |  0.00
Modify  | 0.33498    | 0.33498    | 0.33498    |   0.0 |  0.15
Other   |            | 0.05935    |            |       |  0.03

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

Total # of neighbors = 132610
Ave neighs/atom = 66.305000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8415.3266   -8415.3266   -8494.5896   -8494.5896     306.7557     306.7557    23419.683    23419.683   -1830.8253   -1830.8253 
    3000   -8416.6119   -8416.6119   -8500.4611   -8500.4611    324.50472    324.50472    23374.918    23374.918    688.39578    688.39578 
Loop time of 224.48 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.385 ns/day, 62.356 hours/ns, 4.455 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    | 223.99     | 223.99     | 223.99     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093271   | 0.093271   | 0.093271   |   0.0 |  0.04
Output  | 0.00018916 | 0.00018916 | 0.00018916 |   0.0 |  0.00
Modify  | 0.3324     | 0.3324     | 0.3324     |   0.0 |  0.15
Other   |            | 0.05935    |            |       |  0.03

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

Total # of neighbors = 132288
Ave neighs/atom = 66.144000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8416.6119   -8416.6119   -8500.4611   -8500.4611    324.50472    324.50472    23374.918    23374.918    688.39578    688.39578 
    4000   -8414.7524   -8414.7524    -8495.702    -8495.702    313.28353    313.28353     23386.54     23386.54    538.76807    538.76807 
Loop time of 225.011 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.384 ns/day, 62.503 hours/ns, 4.444 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    | 224.53     | 224.53     | 224.53     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093352   | 0.093352   | 0.093352   |   0.0 |  0.04
Output  | 0.00019259 | 0.00019259 | 0.00019259 |   0.0 |  0.00
Modify  | 0.33252    | 0.33252    | 0.33252    |   0.0 |  0.15
Other   |            | 0.05903    |            |       |  0.03

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

Total # of neighbors = 131692
Ave neighs/atom = 65.846000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8414.7524   -8414.7524    -8495.702    -8495.702    313.28353    313.28353     23386.54     23386.54    538.76807    538.76807 
    5000    -8417.353    -8417.353   -8498.3992   -8498.3992    313.65728    313.65728    23418.079    23418.079    -2029.098    -2029.098 
Loop time of 225.117 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.384 ns/day, 62.533 hours/ns, 4.442 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.63     | 224.63     | 224.63     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094403   | 0.094403   | 0.094403   |   0.0 |  0.04
Output  | 0.00015901 | 0.00015901 | 0.00015901 |   0.0 |  0.00
Modify  | 0.33536    | 0.33536    | 0.33536    |   0.0 |  0.15
Other   |            | 0.05877    |            |       |  0.03

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

Total # of neighbors = 132190
Ave neighs/atom = 66.095000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 310.58497002385, Press = -301.499217261209
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000    -8417.353    -8417.353   -8498.3992   -8498.3992    313.65728    313.65728    23418.079    23418.079    -2029.098    -2029.098 
    6000   -8415.7195   -8415.7195   -8493.5207   -8493.5207    301.09844    301.09844    23410.547    23410.547   -952.11011   -952.11011 
Loop time of 259.505 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.333 ns/day, 72.085 hours/ns, 3.853 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    | 258.9      | 258.9      | 258.9      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10824    | 0.10824    | 0.10824    |   0.0 |  0.04
Output  | 0.00023244 | 0.00023244 | 0.00023244 |   0.0 |  0.00
Modify  | 0.43289    | 0.43289    | 0.43289    |   0.0 |  0.17
Other   |            | 0.06598    |            |       |  0.03

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

Total # of neighbors = 131828
Ave neighs/atom = 65.914000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.152151164173, Press = 80.459584750637
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8415.7195   -8415.7195   -8493.5207   -8493.5207    301.09844    301.09844    23410.547    23410.547   -952.11011   -952.11011 
    7000   -8415.3275   -8415.3275   -8495.3721   -8495.3721    309.78074    309.78074     23347.69     23347.69     3385.339     3385.339 
Loop time of 235.042 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.368 ns/day, 65.289 hours/ns, 4.255 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    | 234.51     | 234.51     | 234.51     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098566   | 0.098566   | 0.098566   |   0.0 |  0.04
Output  | 0.00015516 | 0.00015516 | 0.00015516 |   0.0 |  0.00
Modify  | 0.37423    | 0.37423    | 0.37423    |   0.0 |  0.16
Other   |            | 0.06178    |            |       |  0.03

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

Total # of neighbors = 132232
Ave neighs/atom = 66.116000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.236676064291, Press = 16.9090489237042
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8415.3275   -8415.3275   -8495.3721   -8495.3721    309.78074    309.78074     23347.69     23347.69     3385.339     3385.339 
    8000   -8412.8752   -8412.8752    -8496.157    -8496.157    322.30925    322.30925    23391.632    23391.632     231.0717     231.0717 
Loop time of 257.927 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.335 ns/day, 71.646 hours/ns, 3.877 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    | 257.32     | 257.32     | 257.32     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10668    | 0.10668    | 0.10668    |   0.0 |  0.04
Output  | 0.00015424 | 0.00015424 | 0.00015424 |   0.0 |  0.00
Modify  | 0.43007    | 0.43007    | 0.43007    |   0.0 |  0.17
Other   |            | 0.0661     |            |       |  0.03

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

Total # of neighbors = 132298
Ave neighs/atom = 66.149000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.821286590592, Press = -14.1271889810826
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8412.8752   -8412.8752    -8496.157    -8496.157    322.30925    322.30925    23391.632    23391.632     231.0717     231.0717 
    9000    -8416.988    -8416.988   -8496.7735   -8496.7735    308.77795    308.77795    23394.682    23394.682   -285.56431   -285.56431 
Loop time of 229.08 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.56     | 228.56     | 228.56     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095568   | 0.095568   | 0.095568   |   0.0 |  0.04
Output  | 0.00021988 | 0.00021988 | 0.00021988 |   0.0 |  0.00
Modify  | 0.36139    | 0.36139    | 0.36139    |   0.0 |  0.16
Other   |            | 0.06065    |            |       |  0.03

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

Total # of neighbors = 132232
Ave neighs/atom = 66.116000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.887560023466, Press = 0.465880394669149
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000    -8416.988    -8416.988   -8496.7735   -8496.7735    308.77795    308.77795    23394.682    23394.682   -285.56431   -285.56431 
   10000   -8415.1128   -8415.1128   -8497.5496   -8497.5496    319.03884    319.03884    23388.876    23388.876    180.16103    180.16103 
Loop time of 254.675 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.339 ns/day, 70.743 hours/ns, 3.927 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    | 254.08     | 254.08     | 254.08     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1054     | 0.1054     | 0.1054     |   0.0 |  0.04
Output  | 0.00015509 | 0.00015509 | 0.00015509 |   0.0 |  0.00
Modify  | 0.42313    | 0.42313    | 0.42313    |   0.0 |  0.17
Other   |            | 0.06539    |            |       |  0.03

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

Total # of neighbors = 132126
Ave neighs/atom = 66.063000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.421472557299, Press = 5.42806821117302
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8415.1128   -8415.1128   -8497.5496   -8497.5496    319.03884    319.03884    23388.876    23388.876    180.16103    180.16103 
   11000   -8417.8077   -8417.8077   -8496.6767   -8496.6767    305.23109    305.23109    23366.459    23366.459    1685.5262    1685.5262 
Loop time of 260.7 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.09     | 260.09     | 260.09     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10793    | 0.10793    | 0.10793    |   0.0 |  0.04
Output  | 0.00021624 | 0.00021624 | 0.00021624 |   0.0 |  0.00
Modify  | 0.43559    | 0.43559    | 0.43559    |   0.0 |  0.17
Other   |            | 0.06669    |            |       |  0.03

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

Total # of neighbors = 132186
Ave neighs/atom = 66.093000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.272156189181, Press = -5.35583666469735
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8417.8077   -8417.8077   -8496.6767   -8496.6767    305.23109    305.23109    23366.459    23366.459    1685.5262    1685.5262 
   12000   -8417.5143   -8417.5143   -8498.2844   -8498.2844    312.58853    312.58853    23415.622    23415.622   -1806.4468   -1806.4468 
Loop time of 236.988 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.365 ns/day, 65.830 hours/ns, 4.220 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 236.45     | 236.45     | 236.45     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098465   | 0.098465   | 0.098465   |   0.0 |  0.04
Output  | 0.00026308 | 0.00026308 | 0.00026308 |   0.0 |  0.00
Modify  | 0.38079    | 0.38079    | 0.38079    |   0.0 |  0.16
Other   |            | 0.06175    |            |       |  0.03

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

Total # of neighbors = 132292
Ave neighs/atom = 66.146000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.840344988575, Press = -9.37917981641747
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8417.5143   -8417.5143   -8498.2844   -8498.2844    312.58853    312.58853    23415.622    23415.622   -1806.4468   -1806.4468 
   13000   -8415.7797   -8415.7797   -8495.6498   -8495.6498    309.10579    309.10579    23423.025    23423.025    -2164.792    -2164.792 
Loop time of 249.781 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.346 ns/day, 69.384 hours/ns, 4.004 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    | 249.2      | 249.2      | 249.2      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10371    | 0.10371    | 0.10371    |   0.0 |  0.04
Output  | 0.00016095 | 0.00016095 | 0.00016095 |   0.0 |  0.00
Modify  | 0.4128     | 0.4128     | 0.4128     |   0.0 |  0.17
Other   |            | 0.06432    |            |       |  0.03

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

Total # of neighbors = 131712
Ave neighs/atom = 65.856000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.729546835596, Press = 4.99072965944421
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8415.7797   -8415.7797   -8495.6498   -8495.6498    309.10579    309.10579    23423.025    23423.025    -2164.792    -2164.792 
   14000   -8415.4876   -8415.4876   -8496.3767   -8496.3767    313.04929    313.04929    23382.573    23382.573    640.99118    640.99118 
Loop time of 245.948 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.351 ns/day, 68.319 hours/ns, 4.066 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    | 245.38     | 245.38     | 245.38     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10193    | 0.10193    | 0.10193    |   0.0 |  0.04
Output  | 0.00015189 | 0.00015189 | 0.00015189 |   0.0 |  0.00
Modify  | 0.40427    | 0.40427    | 0.40427    |   0.0 |  0.16
Other   |            | 0.06365    |            |       |  0.03

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

Total # of neighbors = 132086
Ave neighs/atom = 66.043000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.744898975855, Press = 6.51245664977362
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8415.4876   -8415.4876   -8496.3767   -8496.3767    313.04929    313.04929    23382.573    23382.573    640.99118    640.99118 
   15000   -8414.2883   -8414.2883   -8495.2056   -8495.2056    313.15828    313.15828    23362.194    23362.194    2385.8513    2385.8513 
Loop time of 252.086 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.343 ns/day, 70.024 hours/ns, 3.967 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    | 251.5      | 251.5      | 251.5      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10472    | 0.10472    | 0.10472    |   0.0 |  0.04
Output  | 0.0015052  | 0.0015052  | 0.0015052  |   0.0 |  0.00
Modify  | 0.41792    | 0.41792    | 0.41792    |   0.0 |  0.17
Other   |            | 0.06498    |            |       |  0.03

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

Total # of neighbors = 132000
Ave neighs/atom = 66.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.102907049523, Press = -0.628149785894486
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8414.2883   -8414.2883   -8495.2056   -8495.2056    313.15828    313.15828    23362.194    23362.194    2385.8513    2385.8513 
   16000   -8414.7706   -8414.7706   -8495.4321   -8495.4321    312.16812    312.16812     23386.49     23386.49     613.6387     613.6387 
Loop time of 242.665 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.356 ns/day, 67.407 hours/ns, 4.121 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    | 242.11     | 242.11     | 242.11     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10058    | 0.10058    | 0.10058    |   0.0 |  0.04
Output  | 0.0001991  | 0.0001991  | 0.0001991  |   0.0 |  0.00
Modify  | 0.39427    | 0.39427    | 0.39427    |   0.0 |  0.16
Other   |            | 0.06402    |            |       |  0.03

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

Total # of neighbors = 132330
Ave neighs/atom = 66.165000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.120514127482, Press = -6.8311177298755
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8414.7706   -8414.7706   -8495.4321   -8495.4321    312.16812    312.16812     23386.49     23386.49     613.6387     613.6387 
   17000   -8417.9775   -8417.9775   -8497.4627   -8497.4627    307.61561    307.61561    23422.525    23422.525   -2383.7861   -2383.7861 
Loop time of 261.106 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.49     | 260.49     | 260.49     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10789    | 0.10789    | 0.10789    |   0.0 |  0.04
Output  | 0.00019424 | 0.00019424 | 0.00019424 |   0.0 |  0.00
Modify  | 0.44021    | 0.44021    | 0.44021    |   0.0 |  0.17
Other   |            | 0.06617    |            |       |  0.03

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

Total # of neighbors = 132104
Ave neighs/atom = 66.052000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.091031158961, Press = -3.69822449134993
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8417.9775   -8417.9775   -8497.4627   -8497.4627    307.61561    307.61561    23422.525    23422.525   -2383.7861   -2383.7861 
   18000    -8410.356    -8410.356   -8492.3738   -8492.3738    317.41756    317.41756    23403.379    23403.379   -155.99323   -155.99323 
Loop time of 259.335 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.333 ns/day, 72.037 hours/ns, 3.856 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    | 258.72     | 258.72     | 258.72     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10712    | 0.10712    | 0.10712    |   0.0 |  0.04
Output  | 0.00021709 | 0.00021709 | 0.00021709 |   0.0 |  0.00
Modify  | 0.43718    | 0.43718    | 0.43718    |   0.0 |  0.17
Other   |            | 0.06642    |            |       |  0.03

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

Total # of neighbors = 131898
Ave neighs/atom = 65.949000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.261112038744, Press = 1.00563330436227
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000    -8410.356    -8410.356   -8492.3738   -8492.3738    317.41756    317.41756    23403.379    23403.379   -155.99323   -155.99323 
   19000   -8417.3087   -8417.3087   -8497.5787   -8497.5787    310.65326    310.65326     23388.53     23388.53    0.7346907    0.7346907 
Loop time of 259.515 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.333 ns/day, 72.087 hours/ns, 3.853 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    | 258.9      | 258.9      | 258.9      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10665    | 0.10665    | 0.10665    |   0.0 |  0.04
Output  | 0.00015613 | 0.00015613 | 0.00015613 |   0.0 |  0.00
Modify  | 0.43696    | 0.43696    | 0.43696    |   0.0 |  0.17
Other   |            | 0.0661     |            |       |  0.03

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

Total # of neighbors = 132280
Ave neighs/atom = 66.140000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.324198045519, Press = 0.689195845443073
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8417.3087   -8417.3087   -8497.5787   -8497.5787    310.65326    310.65326     23388.53     23388.53    0.7346907    0.7346907 
   20000   -8413.8666   -8413.8666   -8495.4971   -8495.4971    315.91865    315.91865    23388.362    23388.362    438.66487    438.66487 
Loop time of 261.216 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.6      | 260.6      | 260.6      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10808    | 0.10808    | 0.10808    |   0.0 |  0.04
Output  | 0.00015626 | 0.00015626 | 0.00015626 |   0.0 |  0.00
Modify  | 0.44098    | 0.44098    | 0.44098    |   0.0 |  0.17
Other   |            | 0.0664     |            |       |  0.03

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

Total # of neighbors = 132148
Ave neighs/atom = 66.074000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.45872224428, Press = 0.276199029329859
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8413.8666   -8413.8666   -8495.4971   -8495.4971    315.91865    315.91865    23388.362    23388.362    438.66487    438.66487 
   21000   -8414.9243   -8414.9243   -8495.4373   -8495.4373    311.59364    311.59364    23379.378    23379.378    1098.2453    1098.2453 
Loop time of 228.267 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.408 hours/ns, 4.381 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.75     | 227.75     | 227.75     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096049   | 0.096049   | 0.096049   |   0.0 |  0.04
Output  | 0.00015669 | 0.00015669 | 0.00015669 |   0.0 |  0.00
Modify  | 0.36076    | 0.36076    | 0.36076    |   0.0 |  0.16
Other   |            | 0.05978    |            |       |  0.03

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

Total # of neighbors = 132222
Ave neighs/atom = 66.111000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.397774815034, Press = -0.776073700624637
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8414.9243   -8414.9243   -8495.4373   -8495.4373    311.59364    311.59364    23379.378    23379.378    1098.2453    1098.2453 
   22000   -8417.0035   -8417.0035   -8498.8077   -8498.8077    316.59079    316.59079    23411.064    23411.064   -1644.5089   -1644.5089 
Loop time of 257.557 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.335 ns/day, 71.544 hours/ns, 3.883 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    | 256.95     | 256.95     | 256.95     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10718    | 0.10718    | 0.10718    |   0.0 |  0.04
Output  | 0.00019857 | 0.00019857 | 0.00019857 |   0.0 |  0.00
Modify  | 0.43163    | 0.43163    | 0.43163    |   0.0 |  0.17
Other   |            | 0.06711    |            |       |  0.03

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

Total # of neighbors = 132242
Ave neighs/atom = 66.121000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.415129000272, Press = -3.48447852097503
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8417.0035   -8417.0035   -8498.8077   -8498.8077    316.59079    316.59079    23411.064    23411.064   -1644.5089   -1644.5089 
   23000   -8418.5519   -8418.5519   -8497.4234   -8497.4234    305.24084    305.24084    23411.619    23411.619   -1641.3398   -1641.3398 
Loop time of 261.988 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.330 ns/day, 72.774 hours/ns, 3.817 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    | 261.37     | 261.37     | 261.37     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10893    | 0.10893    | 0.10893    |   0.0 |  0.04
Output  | 0.00016007 | 0.00016007 | 0.00016007 |   0.0 |  0.00
Modify  | 0.44543    | 0.44543    | 0.44543    |   0.0 |  0.17
Other   |            | 0.06737    |            |       |  0.03

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

Total # of neighbors = 131930
Ave neighs/atom = 65.965000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.202088544328, Press = 1.88618592742163
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8418.5519   -8418.5519   -8497.4234   -8497.4234    305.24084    305.24084    23411.619    23411.619   -1641.3398   -1641.3398 
   24000   -8415.2952   -8415.2952   -8498.2048   -8498.2048    320.86851    320.86851     23368.75     23368.75    1422.6112    1422.6112 
Loop time of 249.901 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.346 ns/day, 69.417 hours/ns, 4.002 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    | 249.32     | 249.32     | 249.32     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10424    | 0.10424    | 0.10424    |   0.0 |  0.04
Output  | 0.00015569 | 0.00015569 | 0.00015569 |   0.0 |  0.00
Modify  | 0.4118     | 0.4118     | 0.4118     |   0.0 |  0.16
Other   |            | 0.06489    |            |       |  0.03

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

Total # of neighbors = 131820
Ave neighs/atom = 65.910000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.171271038114, Press = 2.44320434530155
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8415.2952   -8415.2952   -8498.2048   -8498.2048    320.86851    320.86851     23368.75     23368.75    1422.6112    1422.6112 
   25000   -8417.8448   -8417.8448   -8499.4562   -8499.4562     315.8445     315.8445    23344.363    23344.363    2864.4729    2864.4729 
Loop time of 251.997 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.343 ns/day, 69.999 hours/ns, 3.968 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    | 251.41     | 251.41     | 251.41     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10399    | 0.10399    | 0.10399    |   0.0 |  0.04
Output  | 0.00018772 | 0.00018772 | 0.00018772 |   0.0 |  0.00
Modify  | 0.41501    | 0.41501    | 0.41501    |   0.0 |  0.16
Other   |            | 0.0646     |            |       |  0.03

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

Total # of neighbors = 132150
Ave neighs/atom = 66.075000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.024824354911, Press = -2.4169627158535
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8417.8448   -8417.8448   -8499.4562   -8499.4562     315.8445     315.8445    23344.363    23344.363    2864.4729    2864.4729 
   26000   -8417.9369   -8417.9369   -8498.4867   -8498.4867    311.73625    311.73625    23424.203    23424.203   -2629.9551   -2629.9551 
Loop time of 244.397 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.354 ns/day, 67.888 hours/ns, 4.092 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 243.83     | 243.83     | 243.83     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10227    | 0.10227    | 0.10227    |   0.0 |  0.04
Output  | 0.00021511 | 0.00021511 | 0.00021511 |   0.0 |  0.00
Modify  | 0.40228    | 0.40228    | 0.40228    |   0.0 |  0.16
Other   |            | 0.06373    |            |       |  0.03

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

Total # of neighbors = 132176
Ave neighs/atom = 66.088000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.0212051066, Press = -6.56212887166833
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8417.9369   -8417.9369   -8498.4867   -8498.4867    311.73625    311.73625    23424.203    23424.203   -2629.9551   -2629.9551 
   27000    -8412.942    -8412.942   -8495.1302   -8495.1302    318.07686    318.07686    23425.071    23425.071   -2011.1169   -2011.1169 
Loop time of 258.449 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.334 ns/day, 71.791 hours/ns, 3.869 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    | 257.84     | 257.84     | 257.84     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1073     | 0.1073     | 0.1073     |   0.0 |  0.04
Output  | 0.00019385 | 0.00019385 | 0.00019385 |   0.0 |  0.00
Modify  | 0.43385    | 0.43385    | 0.43385    |   0.0 |  0.17
Other   |            | 0.06599    |            |       |  0.03

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

Total # of neighbors = 131918
Ave neighs/atom = 65.959000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.014863500122, Press = 0.645297605374108
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000    -8412.942    -8412.942   -8495.1302   -8495.1302    318.07686    318.07686    23425.071    23425.071   -2011.1169   -2011.1169 
   28000   -8416.6575   -8416.6575   -8497.7752   -8497.7752    313.93396    313.93396    23388.951    23388.951   -47.196698   -47.196698 
Loop time of 260.03 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.332 ns/day, 72.230 hours/ns, 3.846 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    | 259.42     | 259.42     | 259.42     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10794    | 0.10794    | 0.10794    |   0.0 |  0.04
Output  | 0.00019839 | 0.00019839 | 0.00019839 |   0.0 |  0.00
Modify  | 0.43583    | 0.43583    | 0.43583    |   0.0 |  0.17
Other   |            | 0.0665     |            |       |  0.03

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

Total # of neighbors = 132128
Ave neighs/atom = 66.064000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.042429026064, Press = 1.38107933379086
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8416.6575   -8416.6575   -8497.7752   -8497.7752    313.93396    313.93396    23388.951    23388.951   -47.196698   -47.196698 
   29000   -8415.8228   -8415.8228   -8496.4264   -8496.4264    311.94426    311.94426     23372.02     23372.02    1418.7646    1418.7646 
Loop time of 262.136 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.330 ns/day, 72.816 hours/ns, 3.815 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    | 261.52     | 261.52     | 261.52     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10867    | 0.10867    | 0.10867    |   0.0 |  0.04
Output  | 0.00015482 | 0.00015482 | 0.00015482 |   0.0 |  0.00
Modify  | 0.44029    | 0.44029    | 0.44029    |   0.0 |  0.17
Other   |            | 0.06698    |            |       |  0.03

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

Total # of neighbors = 131940
Ave neighs/atom = 65.970000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.954020025601, Press = 0.305943204338849
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8415.8228   -8415.8228   -8496.4264   -8496.4264    311.94426    311.94426     23372.02     23372.02    1418.7646    1418.7646 
   30000   -8420.0741   -8420.0741   -8497.8539   -8497.8539    301.01615    301.01615    23383.906    23383.906    250.70467    250.70467 
Loop time of 261.41 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.614 hours/ns, 3.825 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.79     | 260.79     | 260.79     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10866    | 0.10866    | 0.10866    |   0.0 |  0.04
Output  | 0.00021869 | 0.00021869 | 0.00021869 |   0.0 |  0.00
Modify  | 0.4405     | 0.4405     | 0.4405     |   0.0 |  0.17
Other   |            | 0.0667     |            |       |  0.03

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

Total # of neighbors = 132314
Ave neighs/atom = 66.157000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.919852137013, Press = -3.24827220178196
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8420.0741   -8420.0741   -8497.8539   -8497.8539    301.01615    301.01615    23383.906    23383.906    250.70467    250.70467 
   31000   -8415.2085   -8415.2085    -8495.368    -8495.368     310.2258     310.2258    23454.005    23454.005   -4137.4897   -4137.4897 
Loop time of 262.516 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.329 ns/day, 72.921 hours/ns, 3.809 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    | 261.9      | 261.9      | 261.9      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1095     | 0.1095     | 0.1095     |   0.0 |  0.04
Output  | 0.00015673 | 0.00015673 | 0.00015673 |   0.0 |  0.00
Modify  | 0.44033    | 0.44033    | 0.44033    |   0.0 |  0.17
Other   |            | 0.06648    |            |       |  0.03

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

Total # of neighbors = 132024
Ave neighs/atom = 66.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.84237592298, Press = -0.898644591342553
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8415.2085   -8415.2085    -8495.368    -8495.368     310.2258     310.2258    23454.005    23454.005   -4137.4897   -4137.4897 
   32000    -8417.538    -8417.538   -8497.1455   -8497.1455    308.08902    308.08902    23390.398    23390.398   -89.719793   -89.719793 
Loop time of 257.379 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.336 ns/day, 71.494 hours/ns, 3.885 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    | 256.78     | 256.78     | 256.78     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10554    | 0.10554    | 0.10554    |   0.0 |  0.04
Output  | 0.00015765 | 0.00015765 | 0.00015765 |   0.0 |  0.00
Modify  | 0.4279     | 0.4279     | 0.4279     |   0.0 |  0.17
Other   |            | 0.06529    |            |       |  0.03

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

Total # of neighbors = 131820
Ave neighs/atom = 65.910000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.814904853858, Press = 3.34096060559756
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    -8417.538    -8417.538   -8497.1455   -8497.1455    308.08902    308.08902    23390.398    23390.398   -89.719793   -89.719793 
   33000   -8415.3842   -8415.3842    -8495.337    -8495.337    309.42555    309.42555    23356.409    23356.409    2606.8183    2606.8183 
Loop time of 245.074 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.353 ns/day, 68.076 hours/ns, 4.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    | 244.51     | 244.51     | 244.51     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10249    | 0.10249    | 0.10249    |   0.0 |  0.04
Output  | 0.00015639 | 0.00015639 | 0.00015639 |   0.0 |  0.00
Modify  | 0.40289    | 0.40289    | 0.40289    |   0.0 |  0.16
Other   |            | 0.06343    |            |       |  0.03

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

Total # of neighbors = 132068
Ave neighs/atom = 66.034000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.876078174318, Press = 0.246842495251859
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8415.3842   -8415.3842    -8495.337    -8495.337    309.42555    309.42555    23356.409    23356.409    2606.8183    2606.8183 
   34000    -8413.638    -8413.638   -8495.6852   -8495.6852    317.53086    317.53086    23383.554    23383.554    756.95754    756.95754 
Loop time of 261.37 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.603 hours/ns, 3.826 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.75     | 260.75     | 260.75     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10895    | 0.10895    | 0.10895    |   0.0 |  0.04
Output  | 0.00021136 | 0.00021136 | 0.00021136 |   0.0 |  0.00
Modify  | 0.44105    | 0.44105    | 0.44105    |   0.0 |  0.17
Other   |            | 0.0681     |            |       |  0.03

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

Total # of neighbors = 132368
Ave neighs/atom = 66.184000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.892221088121, Press = -1.47689347431255
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000    -8413.638    -8413.638   -8495.6852   -8495.6852    317.53086    317.53086    23383.554    23383.554    756.95754    756.95754 
   35000   -8417.2242   -8417.2242    -8497.247    -8497.247    309.69646    309.69646     23411.42     23411.42   -1569.0097   -1569.0097 
Loop time of 253.766 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.340 ns/day, 70.491 hours/ns, 3.941 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    | 253.17     | 253.17     | 253.17     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10514    | 0.10514    | 0.10514    |   0.0 |  0.04
Output  | 0.00019864 | 0.00019864 | 0.00019864 |   0.0 |  0.00
Modify  | 0.42124    | 0.42124    | 0.42124    |   0.0 |  0.17
Other   |            | 0.06601    |            |       |  0.03

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

Total # of neighbors = 132282
Ave neighs/atom = 66.141000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.003507096573, Press = -0.98530362902352
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8417.2242   -8417.2242    -8497.247    -8497.247    309.69646    309.69646     23411.42     23411.42   -1569.0097   -1569.0097 
   36000   -8412.9253   -8412.9253   -8496.7283   -8496.7283    324.32613    324.32613    23436.833    23436.833   -2981.9177   -2981.9177 
Loop time of 261.16 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.545 hours/ns, 3.829 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.55     | 260.55     | 260.55     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10786    | 0.10786    | 0.10786    |   0.0 |  0.04
Output  | 0.00015604 | 0.00015604 | 0.00015604 |   0.0 |  0.00
Modify  | 0.43788    | 0.43788    | 0.43788    |   0.0 |  0.17
Other   |            | 0.06606    |            |       |  0.03

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

Total # of neighbors = 131894
Ave neighs/atom = 65.947000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.040562658649, Press = 1.81344160591478
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8412.9253   -8412.9253   -8496.7283   -8496.7283    324.32613    324.32613    23436.833    23436.833   -2981.9177   -2981.9177 
   37000   -8416.2887   -8416.2887   -8496.4774   -8496.4774    310.33827    310.33827    23349.707    23349.707    2977.5586    2977.5586 
Loop time of 259.73 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.333 ns/day, 72.147 hours/ns, 3.850 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 259.12     | 259.12     | 259.12     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10736    | 0.10736    | 0.10736    |   0.0 |  0.04
Output  | 0.00015622 | 0.00015622 | 0.00015622 |   0.0 |  0.00
Modify  | 0.43269    | 0.43269    | 0.43269    |   0.0 |  0.17
Other   |            | 0.06606    |            |       |  0.03

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

Total # of neighbors = 131646
Ave neighs/atom = 65.823000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.050870202648, Press = 3.55723691146976
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8416.2887   -8416.2887   -8496.4774   -8496.4774    310.33827    310.33827    23349.707    23349.707    2977.5586    2977.5586 
   38000   -8414.9148   -8414.9148   -8498.7523   -8498.7523    324.45991    324.45991    23361.858    23361.858     1872.921     1872.921 
Loop time of 256.258 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.337 ns/day, 71.183 hours/ns, 3.902 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    | 255.66     | 255.66     | 255.66     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10663    | 0.10663    | 0.10663    |   0.0 |  0.04
Output  | 0.00022218 | 0.00022218 | 0.00022218 |   0.0 |  0.00
Modify  | 0.42978    | 0.42978    | 0.42978    |   0.0 |  0.17
Other   |            | 0.06529    |            |       |  0.03

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

Total # of neighbors = 132402
Ave neighs/atom = 66.201000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.087837024715, Press = -0.872812548379642
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8414.9148   -8414.9148   -8498.7523   -8498.7523    324.45991    324.45991    23361.858    23361.858     1872.921     1872.921 
   39000    -8416.475    -8416.475   -8496.6996   -8496.6996    310.47734    310.47734    23401.235    23401.235   -613.03055   -613.03055 
Loop time of 237.99 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.363 ns/day, 66.108 hours/ns, 4.202 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 237.44     | 237.44     | 237.44     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099502   | 0.099502   | 0.099502   |   0.0 |  0.04
Output  | 0.00015956 | 0.00015956 | 0.00015956 |   0.0 |  0.00
Modify  | 0.38359    | 0.38359    | 0.38359    |   0.0 |  0.16
Other   |            | 0.06163    |            |       |  0.03

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

Total # of neighbors = 132210
Ave neighs/atom = 66.105000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.051424184853, Press = -1.01576946367611
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000    -8416.475    -8416.475   -8496.6996   -8496.6996    310.47734    310.47734    23401.235    23401.235   -613.03055   -613.03055 
   40000   -8415.0401   -8415.0401   -8498.1499   -8498.1499    321.64349    321.64349    23411.675    23411.675   -1511.5116   -1511.5116 
Loop time of 225.022 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.384 ns/day, 62.506 hours/ns, 4.444 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.52     | 224.52     | 224.52     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094633   | 0.094633   | 0.094633   |   0.0 |  0.04
Output  | 0.00019529 | 0.00019529 | 0.00019529 |   0.0 |  0.00
Modify  | 0.35148    | 0.35148    | 0.35148    |   0.0 |  0.16
Other   |            | 0.0592     |            |       |  0.03

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

Total # of neighbors = 131934
Ave neighs/atom = 65.967000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.092770167307, Press = 0.48074655655418
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8415.0401   -8415.0401   -8498.1499   -8498.1499    321.64349    321.64349    23411.675    23411.675   -1511.5116   -1511.5116 
   41000   -8412.7312   -8412.7312   -8496.5078   -8496.5078     324.2242     324.2242    23383.154    23383.154    689.16016    689.16016 
Loop time of 224.997 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.384 ns/day, 62.499 hours/ns, 4.445 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.49     | 224.49     | 224.49     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094407   | 0.094407   | 0.094407   |   0.0 |  0.04
Output  | 0.00046581 | 0.00046581 | 0.00046581 |   0.0 |  0.00
Modify  | 0.35111    | 0.35111    | 0.35111    |   0.0 |  0.16
Other   |            | 0.05897    |            |       |  0.03

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

Total # of neighbors = 131858
Ave neighs/atom = 65.929000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.123758596413, Press = 1.6123333201852
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8412.7312   -8412.7312   -8496.5078   -8496.5078     324.2242     324.2242    23383.154    23383.154    689.16016    689.16016 
   42000   -8412.9327   -8412.9327   -8495.8176   -8495.8176    320.77318    320.77318    23366.129    23366.129    2054.2233    2054.2233 
Loop time of 225.775 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.383 ns/day, 62.715 hours/ns, 4.429 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.27     | 225.27     | 225.27     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094609   | 0.094609   | 0.094609   |   0.0 |  0.04
Output  | 0.00015558 | 0.00015558 | 0.00015558 |   0.0 |  0.00
Modify  | 0.35187    | 0.35187    | 0.35187    |   0.0 |  0.16
Other   |            | 0.05919    |            |       |  0.03

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

Total # of neighbors = 132014
Ave neighs/atom = 66.007000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.152892227411, Press = -0.259125868158032
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8412.9327   -8412.9327   -8495.8176   -8495.8176    320.77318    320.77318    23366.129    23366.129    2054.2233    2054.2233 
   43000   -8417.2982   -8417.2982   -8497.8287   -8497.8287    311.66137    311.66137    23395.852    23395.852   -478.36844   -478.36844 
Loop time of 231.844 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.401 hours/ns, 4.313 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.32     | 231.32     | 231.32     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097058   | 0.097058   | 0.097058   |   0.0 |  0.04
Output  | 0.00019729 | 0.00019729 | 0.00019729 |   0.0 |  0.00
Modify  | 0.36698    | 0.36698    | 0.36698    |   0.0 |  0.16
Other   |            | 0.06003    |            |       |  0.03

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

Total # of neighbors = 132354
Ave neighs/atom = 66.177000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.200189333596, Press = -1.90898075325385
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8417.2982   -8417.2982   -8497.8287   -8497.8287    311.66137    311.66137    23395.852    23395.852   -478.36844   -478.36844 
   44000   -8413.0654   -8413.0654   -8495.1504   -8495.1504    317.67736    317.67736    23435.498    23435.498   -2744.6538   -2744.6538 
Loop time of 229.898 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.38     | 229.38     | 229.38     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09651    | 0.09651    | 0.09651    |   0.0 |  0.04
Output  | 0.00019156 | 0.00019156 | 0.00019156 |   0.0 |  0.00
Modify  | 0.36337    | 0.36337    | 0.36337    |   0.0 |  0.16
Other   |            | 0.0598     |            |       |  0.03

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0