# 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 4.044650807976723*${_u_distance}
variable latticeconst_converted equal 4.044650807976723*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04465080797672
Lattice spacing in x,y,z = 4.0446508 4.0446508 4.0446508
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.446508 40.446508 40.446508)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (40.446508 40.446508 40.446508)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtAl__MO_793141037706_002
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66167.2521387954 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_793141037706_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13278.129     -13278.129     -13440         -13440          313.15         313.15         66167.252      66167.252      2613.0319      2613.0319    
      1000  -13098.01      -13098.01      -13268.515     -13268.515      329.8529       329.8529       67537.287      67537.287     -684.15226     -684.15226    
Loop time of 648.411 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.114 hours/ns, 1.542 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 647.49     | 647.49     | 647.49     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14858    | 0.14858    | 0.14858    |   0.0 |  0.02
Output  | 0.00024629 | 0.00024629 | 0.00024629 |   0.0 |  0.00
Modify  | 0.67675    | 0.67675    | 0.67675    |   0.0 |  0.10
Other   |            | 0.09663    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       536000 ave      536000 max      536000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 536000
Ave neighs/atom = 134
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13098.01      -13098.01      -13268.515     -13268.515      329.8529       329.8529       67537.287      67537.287     -684.15226     -684.15226    
      2000  -13115.997     -13115.997     -13275.36      -13275.36       308.29727      308.29727      67450.684      67450.684     -367.26725     -367.26725    
Loop time of 670.013 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.115 hours/ns, 1.493 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    | 669.08     | 669.08     | 669.08     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15104    | 0.15104    | 0.15104    |   0.0 |  0.02
Output  | 0.0002315  | 0.0002315  | 0.0002315  |   0.0 |  0.00
Modify  | 0.68752    | 0.68752    | 0.68752    |   0.0 |  0.10
Other   |            | 0.09817    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5996 ave        5996 max        5996 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538852 ave      538852 max      538852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538852
Ave neighs/atom = 134.713
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13115.997     -13115.997     -13275.36      -13275.36       308.29727      308.29727      67450.684      67450.684     -367.26725     -367.26725    
      3000  -13103.79      -13103.79      -13261.847     -13261.847      305.77011      305.77011      67429.741      67429.741      751.59021      751.59021    
Loop time of 675.865 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.740 hours/ns, 1.480 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    | 674.92     | 674.92     | 674.92     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1531     | 0.1531     | 0.1531     |   0.0 |  0.02
Output  | 0.00027702 | 0.00027702 | 0.00027702 |   0.0 |  0.00
Modify  | 0.69428    | 0.69428    | 0.69428    |   0.0 |  0.10
Other   |            | 0.09986    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6028 ave        6028 max        6028 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538982 ave      538982 max      538982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538982
Ave neighs/atom = 134.7455
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13103.79      -13103.79      -13261.847     -13261.847      305.77011      305.77011      67429.741      67429.741      751.59021      751.59021    
      4000  -13113.018     -13113.018     -13271.11      -13271.11       305.84106      305.84106      67427.599      67427.599      102.02005      102.02005    
Loop time of 674.068 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.241 hours/ns, 1.484 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    | 673.13     | 673.13     | 673.13     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15191    | 0.15191    | 0.15191    |   0.0 |  0.02
Output  | 0.00023054 | 0.00023054 | 0.00023054 |   0.0 |  0.00
Modify  | 0.68716    | 0.68716    | 0.68716    |   0.0 |  0.10
Other   |            | 0.09866    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6012 ave        6012 max        6012 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539162 ave      539162 max      539162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539162
Ave neighs/atom = 134.7905
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13113.018     -13113.018     -13271.11      -13271.11       305.84106      305.84106      67427.599      67427.599      102.02005      102.02005    
      5000  -13107.987     -13107.987     -13267.709     -13267.709      308.99136      308.99136      67511.889      67511.889     -545.01485     -545.01485    
Loop time of 671.434 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.509 hours/ns, 1.489 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    | 670.5      | 670.5      | 670.5      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15107    | 0.15107    | 0.15107    |   0.0 |  0.02
Output  | 0.0001896  | 0.0001896  | 0.0001896  |   0.0 |  0.00
Modify  | 0.68497    | 0.68497    | 0.68497    |   0.0 |  0.10
Other   |            | 0.09854    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6031 ave        6031 max        6031 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539096 ave      539096 max      539096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539096
Ave neighs/atom = 134.774
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 = 317.132924545878, Press = -186.969024509585
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13107.987     -13107.987     -13267.709     -13267.709      308.99136      308.99136      67511.889      67511.889     -545.01485     -545.01485    
      6000  -13108.827     -13108.827     -13270.895     -13270.895      313.5311       313.5311       67454.552      67454.552     -80.290817     -80.290817    
Loop time of 670.057 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.127 hours/ns, 1.492 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    | 669.1      | 669.1      | 669.1      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1507     | 0.1507     | 0.1507     |   0.0 |  0.02
Output  | 0.00018877 | 0.00018877 | 0.00018877 |   0.0 |  0.00
Modify  | 0.70632    | 0.70632    | 0.70632    |   0.0 |  0.11
Other   |            | 0.09834    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5984 ave        5984 max        5984 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539024 ave      539024 max      539024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539024
Ave neighs/atom = 134.756
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.762119547448, Press = 31.0736549205131
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13108.827     -13108.827     -13270.895     -13270.895      313.5311       313.5311       67454.552      67454.552     -80.290817     -80.290817    
      7000  -13109.975     -13109.975     -13273.111     -13273.111      315.5984       315.5984       67300.245      67300.245      1537.6322      1537.6322    
Loop time of 673.676 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.132 hours/ns, 1.484 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    | 672.71     | 672.71     | 672.71     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15159    | 0.15159    | 0.15159    |   0.0 |  0.02
Output  | 0.00023455 | 0.00023455 | 0.00023455 |   0.0 |  0.00
Modify  | 0.71256    | 0.71256    | 0.71256    |   0.0 |  0.11
Other   |            | 0.0981     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6022 ave        6022 max        6022 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539100 ave      539100 max      539100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539100
Ave neighs/atom = 134.775
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.180326864953, Press = -9.31791178484717
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13109.975     -13109.975     -13273.111     -13273.111      315.5984       315.5984       67300.245      67300.245      1537.6322      1537.6322    
      8000  -13108.808     -13108.808     -13271.001     -13271.001      313.77387      313.77387      67487.081      67487.081     -508.19195     -508.19195    
Loop time of 674.356 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.321 hours/ns, 1.483 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    | 673.4      | 673.4      | 673.4      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15096    | 0.15096    | 0.15096    |   0.0 |  0.02
Output  | 0.00023529 | 0.00023529 | 0.00023529 |   0.0 |  0.00
Modify  | 0.71155    | 0.71155    | 0.71155    |   0.0 |  0.11
Other   |            | 0.09771    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6018 ave        6018 max        6018 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539348 ave      539348 max      539348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539348
Ave neighs/atom = 134.837
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.850385225737, Press = -10.6058496609749
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13108.808     -13108.808     -13271.001     -13271.001      313.77387      313.77387      67487.081      67487.081     -508.19195     -508.19195    
      9000  -13114.433     -13114.433     -13276.509     -13276.509      313.546        313.546        67465.528      67465.528     -604.55534     -604.55534    
Loop time of 672.826 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 186.896 hours/ns, 1.486 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    | 671.87     | 671.87     | 671.87     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15188    | 0.15188    | 0.15188    |   0.0 |  0.02
Output  | 0.00019118 | 0.00019118 | 0.00019118 |   0.0 |  0.00
Modify  | 0.70896    | 0.70896    | 0.70896    |   0.0 |  0.11
Other   |            | 0.09823    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6054 ave        6054 max        6054 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538892 ave      538892 max      538892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538892
Ave neighs/atom = 134.723
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.670534064694, Press = 0.491177655441837
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13114.433     -13114.433     -13276.509     -13276.509      313.546        313.546        67465.528      67465.528     -604.55534     -604.55534    
     10000  -13108.13      -13108.13      -13271.048     -13271.048      315.1775       315.1775       67422.412      67422.412      204.71641      204.71641    
Loop time of 673.981 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.217 hours/ns, 1.484 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    | 673.02     | 673.02     | 673.02     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15068    | 0.15068    | 0.15068    |   0.0 |  0.02
Output  | 0.00018747 | 0.00018747 | 0.00018747 |   0.0 |  0.00
Modify  | 0.71205    | 0.71205    | 0.71205    |   0.0 |  0.11
Other   |            | 0.09892    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5994 ave        5994 max        5994 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538996 ave      538996 max      538996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538996
Ave neighs/atom = 134.749
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.466599233449, Press = 0.130584937923485
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13108.13      -13108.13      -13271.048     -13271.048      315.1775       315.1775       67422.412      67422.412      204.71641      204.71641    
     11000  -13109.892     -13109.892     -13273.734     -13273.734      316.9646       316.9646       67421.911      67421.911      99.211916      99.211916    
Loop time of 673.5 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.083 hours/ns, 1.485 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    | 672.54     | 672.54     | 672.54     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15128    | 0.15128    | 0.15128    |   0.0 |  0.02
Output  | 0.00024181 | 0.00024181 | 0.00024181 |   0.0 |  0.00
Modify  | 0.71061    | 0.71061    | 0.71061    |   0.0 |  0.11
Other   |            | 0.09838    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6017 ave        6017 max        6017 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538982 ave      538982 max      538982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538982
Ave neighs/atom = 134.7455
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.429907893629, Press = -3.78076145799285
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13109.892     -13109.892     -13273.734     -13273.734      316.9646       316.9646       67421.911      67421.911      99.211916      99.211916    
     12000  -13108.149     -13108.149     -13269.985     -13269.985      313.08258      313.08258      67573.517      67573.517     -1368.4828     -1368.4828    
Loop time of 672.328 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.758 hours/ns, 1.487 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    | 671.37     | 671.37     | 671.37     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14909    | 0.14909    | 0.14909    |   0.0 |  0.02
Output  | 0.00018828 | 0.00018828 | 0.00018828 |   0.0 |  0.00
Modify  | 0.71041    | 0.71041    | 0.71041    |   0.0 |  0.11
Other   |            | 0.09827    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5968 ave        5968 max        5968 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538896 ave      538896 max      538896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538896
Ave neighs/atom = 134.724
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.83157852901, Press = -5.81053507220589
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13108.149     -13108.149     -13269.985     -13269.985      313.08258      313.08258      67573.517      67573.517     -1368.4828     -1368.4828    
     13000  -13108.537     -13108.537     -13271.134     -13271.134      314.55577      314.55577      67492.607      67492.607     -547.00409     -547.00409    
Loop time of 670.093 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.137 hours/ns, 1.492 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    | 669.14     | 669.14     | 669.14     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14918    | 0.14918    | 0.14918    |   0.0 |  0.02
Output  | 0.00019096 | 0.00019096 | 0.00019096 |   0.0 |  0.00
Modify  | 0.70997    | 0.70997    | 0.70997    |   0.0 |  0.11
Other   |            | 0.09841    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5952 ave        5952 max        5952 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538734 ave      538734 max      538734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538734
Ave neighs/atom = 134.6835
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.887307041593, Press = 5.52224042410433
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13108.537     -13108.537     -13271.134     -13271.134      314.55577      314.55577      67492.607      67492.607     -547.00409     -547.00409    
     14000  -13103.835     -13103.835     -13270.275     -13270.275      321.98826      321.98826      67393.49       67393.49       665.55016      665.55016    
Loop time of 668.812 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 185.781 hours/ns, 1.495 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    | 667.86     | 667.86     | 667.86     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15057    | 0.15057    | 0.15057    |   0.0 |  0.02
Output  | 0.00045226 | 0.00045226 | 0.00045226 |   0.0 |  0.00
Modify  | 0.70378    | 0.70378    | 0.70378    |   0.0 |  0.11
Other   |            | 0.09741    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6050 ave        6050 max        6050 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539002 ave      539002 max      539002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539002
Ave neighs/atom = 134.7505
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.158065469246, Press = -0.782981286892562
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13103.835     -13103.835     -13270.275     -13270.275      321.98826      321.98826      67393.49       67393.49       665.55016      665.55016    
     15000  -13111.235     -13111.235     -13272.691     -13272.691      312.34757      312.34757      67454.362      67454.362     -227.05851     -227.05851    
Loop time of 673.59 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.108 hours/ns, 1.485 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    | 672.63     | 672.63     | 672.63     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15047    | 0.15047    | 0.15047    |   0.0 |  0.02
Output  | 0.00022855 | 0.00022855 | 0.00022855 |   0.0 |  0.00
Modify  | 0.71258    | 0.71258    | 0.71258    |   0.0 |  0.11
Other   |            | 0.09914    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6011 ave        6011 max        6011 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539282 ave      539282 max      539282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539282
Ave neighs/atom = 134.8205
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.222459529017, Press = -3.12578838326699
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13111.235     -13111.235     -13272.691     -13272.691      312.34757      312.34757      67454.362      67454.362     -227.05851     -227.05851    
     16000  -13103.88      -13103.88      -13266.86      -13266.86       315.29442      315.29442      67556.932      67556.932     -932.56011     -932.56011    
Loop time of 673.21 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.003 hours/ns, 1.485 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    | 672.24     | 672.24     | 672.24     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1538     | 0.1538     | 0.1538     |   0.0 |  0.02
Output  | 0.00018974 | 0.00018974 | 0.00018974 |   0.0 |  0.00
Modify  | 0.72233    | 0.72233    | 0.72233    |   0.0 |  0.11
Other   |            | 0.09856    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6050 ave        6050 max        6050 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539030 ave      539030 max      539030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539030
Ave neighs/atom = 134.7575
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.35041926657, Press = 0.26792815833494
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13103.88      -13103.88      -13266.86      -13266.86       315.29442      315.29442      67556.932      67556.932     -932.56011     -932.56011    
     17000  -13110.651     -13110.651     -13270.715     -13270.715      309.65572      309.65572      67391.147      67391.147      584.15678      584.15678    
Loop time of 675.177 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.549 hours/ns, 1.481 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    | 674.22     | 674.22     | 674.22     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14991    | 0.14991    | 0.14991    |   0.0 |  0.02
Output  | 0.00019221 | 0.00019221 | 0.00019221 |   0.0 |  0.00
Modify  | 0.71122    | 0.71122    | 0.71122    |   0.0 |  0.11
Other   |            | 0.1001     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5958 ave        5958 max        5958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538938 ave      538938 max      538938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538938
Ave neighs/atom = 134.7345
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.402569240286, Press = 3.14531110334198
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13110.651     -13110.651     -13270.715     -13270.715      309.65572      309.65572      67391.147      67391.147      584.15678      584.15678    
     18000  -13108.247     -13108.247     -13271.201     -13271.201      315.24501      315.24501      67393.263      67393.263      604.84235      604.84235    
Loop time of 675.397 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.610 hours/ns, 1.481 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    | 674.43     | 674.43     | 674.43     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15458    | 0.15458    | 0.15458    |   0.0 |  0.02
Output  | 0.00020016 | 0.00020016 | 0.00020016 |   0.0 |  0.00
Modify  | 0.71639    | 0.71639    | 0.71639    |   0.0 |  0.11
Other   |            | 0.09895    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6103 ave        6103 max        6103 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539204 ave      539204 max      539204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539204
Ave neighs/atom = 134.801
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.388520876287, Press = -1.48474987188764
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13108.247     -13108.247     -13271.201     -13271.201      315.24501      315.24501      67393.263      67393.263      604.84235      604.84235    
     19000  -13111.893     -13111.893     -13273.239     -13273.239      312.13505      312.13505      67471.341      67471.341     -544.76386     -544.76386    
Loop time of 678.178 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.383 hours/ns, 1.475 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    | 677.21     | 677.21     | 677.21     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1513     | 0.1513     | 0.1513     |   0.0 |  0.02
Output  | 0.00018739 | 0.00018739 | 0.00018739 |   0.0 |  0.00
Modify  | 0.72251    | 0.72251    | 0.72251    |   0.0 |  0.11
Other   |            | 0.09914    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6038 ave        6038 max        6038 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539110 ave      539110 max      539110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539110
Ave neighs/atom = 134.7775
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.264978692595, Press = -0.996142794499372
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13111.893     -13111.893     -13273.239     -13273.239      312.13505      312.13505      67471.341      67471.341     -544.76386     -544.76386    
     20000  -13108.326     -13108.326     -13272.194     -13272.194      317.01338      317.01338      67454.151      67454.151     -185.00596     -185.00596    
Loop time of 673.294 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.026 hours/ns, 1.485 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    | 672.33     | 672.33     | 672.33     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15218    | 0.15218    | 0.15218    |   0.0 |  0.02
Output  | 0.00018583 | 0.00018583 | 0.00018583 |   0.0 |  0.00
Modify  | 0.71497    | 0.71497    | 0.71497    |   0.0 |  0.11
Other   |            | 0.09868    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6060 ave        6060 max        6060 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538992 ave      538992 max      538992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538992
Ave neighs/atom = 134.748
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.194211096361, Press = 0.204477763125798
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13108.326     -13108.326     -13272.194     -13272.194      317.01338      317.01338      67454.151      67454.151     -185.00596     -185.00596    
     21000  -13108.061     -13108.061     -13268.9       -13268.9        311.15429      311.15429      67375.76       67375.76       890.91248      890.91248    
Loop time of 678.649 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.514 hours/ns, 1.474 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    | 677.68     | 677.68     | 677.68     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15149    | 0.15149    | 0.15149    |   0.0 |  0.02
Output  | 0.00024548 | 0.00024548 | 0.00024548 |   0.0 |  0.00
Modify  | 0.71479    | 0.71479    | 0.71479    |   0.0 |  0.11
Other   |            | 0.09812    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6011 ave        6011 max        6011 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538998 ave      538998 max      538998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538998
Ave neighs/atom = 134.7495
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.170571048316, Press = -0.839513308926984
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13108.061     -13108.061     -13268.9       -13268.9        311.15429      311.15429      67375.76       67375.76       890.91248      890.91248    
     22000  -13111.025     -13111.025     -13270.742     -13270.742      308.98368      308.98368      67518.982      67518.982     -902.38727     -902.38727    
Loop time of 681.183 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.217 hours/ns, 1.468 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    | 680.21     | 680.21     | 680.21     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1509     | 0.1509     | 0.1509     |   0.0 |  0.02
Output  | 0.00018922 | 0.00018922 | 0.00018922 |   0.0 |  0.00
Modify  | 0.72477    | 0.72477    | 0.72477    |   0.0 |  0.11
Other   |            | 0.1003     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6020 ave        6020 max        6020 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539152 ave      539152 max      539152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539152
Ave neighs/atom = 134.788
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.193334562665, Press = -4.70312387887281
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13111.025     -13111.025     -13270.742     -13270.742      308.98368      308.98368      67518.982      67518.982     -902.38727     -902.38727    
     23000  -13107.098     -13107.098     -13267.612     -13267.612      310.52554      310.52554      67541.632      67541.632     -877.21867     -877.21867    
Loop time of 683.233 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 189.787 hours/ns, 1.464 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 682.25     | 682.25     | 682.25     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15169    | 0.15169    | 0.15169    |   0.0 |  0.02
Output  | 0.00022409 | 0.00022409 | 0.00022409 |   0.0 |  0.00
Modify  | 0.72791    | 0.72791    | 0.72791    |   0.0 |  0.11
Other   |            | 0.1004     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6006 ave        6006 max        6006 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538980 ave      538980 max      538980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538980
Ave neighs/atom = 134.745
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.181486652714, Press = 1.30208092914956
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13107.098     -13107.098     -13267.612     -13267.612      310.52554      310.52554      67541.632      67541.632     -877.21867     -877.21867    
     24000  -13108.367     -13108.367     -13272.537     -13272.537      317.59688      317.59688      67392.426      67392.426      553.61286      553.61286    
Loop time of 680.472 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.020 hours/ns, 1.470 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    | 679.5      | 679.5      | 679.5      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15127    | 0.15127    | 0.15127    |   0.0 |  0.02
Output  | 0.00020416 | 0.00020416 | 0.00020416 |   0.0 |  0.00
Modify  | 0.72511    | 0.72511    | 0.72511    |   0.0 |  0.11
Other   |            | 0.09858    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6026 ave        6026 max        6026 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538796 ave      538796 max      538796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538796
Ave neighs/atom = 134.699
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.211790395547, Press = 0.687760060003648
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13108.367     -13108.367     -13272.537     -13272.537      317.59688      317.59688      67392.426      67392.426      553.61286      553.61286    
     25000  -13111.933     -13111.933     -13271.345     -13271.345      308.39494      308.39494      67399.191      67399.191      433.59851      433.59851    
Loop time of 678.701 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.528 hours/ns, 1.473 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    | 677.74     | 677.74     | 677.74     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14965    | 0.14965    | 0.14965    |   0.0 |  0.02
Output  | 0.00023943 | 0.00023943 | 0.00023943 |   0.0 |  0.00
Modify  | 0.71666    | 0.71666    | 0.71666    |   0.0 |  0.11
Other   |            | 0.09897    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6009 ave        6009 max        6009 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539100 ave      539100 max      539100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539100
Ave neighs/atom = 134.775
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.21589638014, Press = -1.4578778966767
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13111.933     -13111.933     -13271.345     -13271.345      308.39494      308.39494      67399.191      67399.191      433.59851      433.59851    
     26000  -13107.622     -13107.622     -13270.264     -13270.264      314.64222      314.64222      67527.431      67527.431     -890.29177     -890.29177    
Loop time of 679.801 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.834 hours/ns, 1.471 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    | 678.83     | 678.83     | 678.83     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15068    | 0.15068    | 0.15068    |   0.0 |  0.02
Output  | 0.00019138 | 0.00019138 | 0.00019138 |   0.0 |  0.00
Modify  | 0.71899    | 0.71899    | 0.71899    |   0.0 |  0.11
Other   |            | 0.09855    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6013 ave        6013 max        6013 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539200 ave      539200 max      539200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539200
Ave neighs/atom = 134.8
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.133677395513, Press = -0.468579575452304
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13107.622     -13107.622     -13270.264     -13270.264      314.64222      314.64222      67527.431      67527.431     -890.29177     -890.29177    
     27000  -13112.953     -13112.953     -13275.413     -13275.413      314.28977      314.28977      67393.429      67393.429      265.91021      265.91021    
Loop time of 675.601 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.667 hours/ns, 1.480 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    | 674.63     | 674.63     | 674.63     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15241    | 0.15241    | 0.15241    |   0.0 |  0.02
Output  | 0.00019    | 0.00019    | 0.00019    |   0.0 |  0.00
Modify  | 0.71892    | 0.71892    | 0.71892    |   0.0 |  0.11
Other   |            | 0.09894    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6045 ave        6045 max        6045 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538922 ave      538922 max      538922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538922
Ave neighs/atom = 134.7305
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.101979182929, Press = 2.63824150396908
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13112.953     -13112.953     -13275.413     -13275.413      314.28977      314.28977      67393.429      67393.429      265.91021      265.91021    
     28000  -13108.473     -13108.473     -13267.716     -13267.716      308.06657      308.06657      67322.302      67322.302      1588.8568      1588.8568    
Loop time of 677.893 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.304 hours/ns, 1.475 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    | 676.93     | 676.93     | 676.93     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14897    | 0.14897    | 0.14897    |   0.0 |  0.02
Output  | 0.00029258 | 0.00029258 | 0.00029258 |   0.0 |  0.00
Modify  | 0.71261    | 0.71261    | 0.71261    |   0.0 |  0.11
Other   |            | 0.09805    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6002 ave        6002 max        6002 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539094 ave      539094 max      539094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539094
Ave neighs/atom = 134.7735
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.095518408832, Press = -1.20004205195852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13108.473     -13108.473     -13267.716     -13267.716      308.06657      308.06657      67322.302      67322.302      1588.8568      1588.8568    
     29000  -13110.735     -13110.735     -13270.61      -13270.61       309.28869      309.28869      67495.721      67495.721     -569.6482      -569.6482     
Loop time of 678.222 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.395 hours/ns, 1.474 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    | 677.26     | 677.26     | 677.26     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15211    | 0.15211    | 0.15211    |   0.0 |  0.02
Output  | 0.00018901 | 0.00018901 | 0.00018901 |   0.0 |  0.00
Modify  | 0.7155     | 0.7155     | 0.7155     |   0.0 |  0.11
Other   |            | 0.09876    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6060 ave        6060 max        6060 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539354 ave      539354 max      539354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539354
Ave neighs/atom = 134.8385
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.092606732884, Press = -1.20093392317646
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13110.735     -13110.735     -13270.61      -13270.61       309.28869      309.28869      67495.721      67495.721     -569.6482      -569.6482     
     30000  -13109.709     -13109.709     -13272.713     -13272.713      315.34241      315.34241      67474.143      67474.143     -414.26626     -414.26626    
Loop time of 682.114 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.476 hours/ns, 1.466 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    | 681.15     | 681.15     | 681.15     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14915    | 0.14915    | 0.14915    |   0.0 |  0.02
Output  | 0.00018836 | 0.00018836 | 0.00018836 |   0.0 |  0.00
Modify  | 0.71695    | 0.71695    | 0.71695    |   0.0 |  0.11
Other   |            | 0.09894    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5989 ave        5989 max        5989 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538948 ave      538948 max      538948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538948
Ave neighs/atom = 134.737
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.070289818901, Press = 0.824454799789723
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13109.709     -13109.709     -13272.713     -13272.713      315.34241      315.34241      67474.143      67474.143     -414.26626     -414.26626    
     31000  -13109.898     -13109.898     -13271.621     -13271.621      312.86414      312.86414      67376.031      67376.031      738.89981      738.89981    
Loop time of 680.065 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.907 hours/ns, 1.470 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    | 679.09     | 679.09     | 679.09     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15064    | 0.15064    | 0.15064    |   0.0 |  0.02
Output  | 0.00019217 | 0.00019217 | 0.00019217 |   0.0 |  0.00
Modify  | 0.7247     | 0.7247     | 0.7247     |   0.0 |  0.11
Other   |            | 0.1001     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6017 ave        6017 max        6017 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538986 ave      538986 max      538986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538986
Ave neighs/atom = 134.7465
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
67446.1145249701

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0