# 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 273.15*${_u_temperature}
variable temp_converted equal 273.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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  -13298.806     -13298.806     -13440         -13440          273.15         273.15         66167.252      66167.252      2279.2583      2279.2583    
      1000  -13142.643     -13142.643     -13293.567     -13293.567      291.97237      291.97237      67223.723      67223.723      796.51608      796.51608    
Loop time of 646.543 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.134 ns/day, 179.595 hours/ns, 1.547 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    | 645.62     | 645.62     | 645.62     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15004    | 0.15004    | 0.15004    |   0.0 |  0.02
Output  | 0.00024442 | 0.00024442 | 0.00024442 |   0.0 |  0.00
Modify  | 0.675      | 0.675      | 0.675      |   0.0 |  0.10
Other   |            | 0.0959     |            |       |  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  -13142.643     -13142.643     -13293.567     -13293.567      291.97237      291.97237      67223.723      67223.723      796.51608      796.51608    
      2000  -13158.024     -13158.024     -13294.654     -13294.654      264.3213       264.3213       67217.302      67217.302      548.54649      548.54649    
Loop time of 672.758 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 186.877 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.83     | 671.83     | 671.83     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15318    | 0.15318    | 0.15318    |   0.0 |  0.02
Output  | 0.00022497 | 0.00022497 | 0.00022497 |   0.0 |  0.00
Modify  | 0.68081    | 0.68081    | 0.68081    |   0.0 |  0.10
Other   |            | 0.09775    |            |       |  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:       539274 ave      539274 max      539274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539274
Ave neighs/atom = 134.8185
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  -13158.024     -13158.024     -13294.654     -13294.654      264.3213       264.3213       67217.302      67217.302      548.54649      548.54649    
      3000  -13148.569     -13148.569     -13286.727     -13286.727      267.27541      267.27541      67264.825      67264.825      485.79849      485.79849    
Loop time of 672.501 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 186.806 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.57     | 671.57     | 671.57     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15443    | 0.15443    | 0.15443    |   0.0 |  0.02
Output  | 0.00030333 | 0.00030333 | 0.00030333 |   0.0 |  0.00
Modify  | 0.68142    | 0.68142    | 0.68142    |   0.0 |  0.10
Other   |            | 0.09858    |            |       |  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:       539296 ave      539296 max      539296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539296
Ave neighs/atom = 134.824
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  -13148.569     -13148.569     -13286.727     -13286.727      267.27541      267.27541      67264.825      67264.825      485.79849      485.79849    
      4000  -13155.15      -13155.15      -13294.921     -13294.921      270.39709      270.39709      67251.479      67251.479      124.87658      124.87658    
Loop time of 673.124 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 186.979 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    | 672.19     | 672.19     | 672.19     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1551     | 0.1551     | 0.1551     |   0.0 |  0.02
Output  | 0.00022634 | 0.00022634 | 0.00022634 |   0.0 |  0.00
Modify  | 0.68324    | 0.68324    | 0.68324    |   0.0 |  0.10
Other   |            | 0.09879    |            |       |  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:       539314 ave      539314 max      539314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539314
Ave neighs/atom = 134.8285
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  -13155.15      -13155.15      -13294.921     -13294.921      270.39709      270.39709      67251.479      67251.479      124.87658      124.87658    
      5000  -13152.5       -13152.5       -13293.216     -13293.216      272.22618      272.22618      67249.256      67249.256      307.60003      307.60003    
Loop time of 668.762 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 185.767 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.83     | 667.83     | 667.83     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15365    | 0.15365    | 0.15365    |   0.0 |  0.02
Output  | 0.00019269 | 0.00019269 | 0.00019269 |   0.0 |  0.00
Modify  | 0.6812     | 0.6812     | 0.6812     |   0.0 |  0.10
Other   |            | 0.0973     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6035 ave        6035 max        6035 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:       539280 ave      539280 max      539280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539280
Ave neighs/atom = 134.82
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 = 274.980908313741, Press = 252.620761876345
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  -13152.5       -13152.5       -13293.216     -13293.216      272.22618      272.22618      67249.256      67249.256      307.60003      307.60003    
      6000  -13150.846     -13150.846     -13290.927     -13290.927      270.99449      270.99449      67245.185      67245.185      512.89685      512.89685    
Loop time of 667.947 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 185.541 hours/ns, 1.497 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    | 666.99     | 666.99     | 666.99     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15322    | 0.15322    | 0.15322    |   0.0 |  0.02
Output  | 0.00018859 | 0.00018859 | 0.00018859 |   0.0 |  0.00
Modify  | 0.70316    | 0.70316    | 0.70316    |   0.0 |  0.11
Other   |            | 0.09709    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5979 ave        5979 max        5979 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:       539266 ave      539266 max      539266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539266
Ave neighs/atom = 134.8165
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 = 272.680665107834, Press = 41.10931216393
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  -13150.846     -13150.846     -13290.927     -13290.927      270.99449      270.99449      67245.185      67245.185      512.89685      512.89685    
      7000  -13154.276     -13154.276     -13293.203     -13293.203      268.76433      268.76433      67254.082      67254.082      153.95285      153.95285    
Loop time of 672.815 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 186.893 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.86     | 671.86     | 671.86     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15447    | 0.15447    | 0.15447    |   0.0 |  0.02
Output  | 0.00019192 | 0.00019192 | 0.00019192 |   0.0 |  0.00
Modify  | 0.70664    | 0.70664    | 0.70664    |   0.0 |  0.11
Other   |            | 0.09781    |            |       |  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:       539248 ave      539248 max      539248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539248
Ave neighs/atom = 134.812
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 = 273.170652902702, Press = 28.6957354637129
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  -13154.276     -13154.276     -13293.203     -13293.203      268.76433      268.76433      67254.082      67254.082      153.95285      153.95285    
      8000  -13151.428     -13151.428     -13294.172     -13294.172      276.14942      276.14942      67298.294      67298.294     -317.79649     -317.79649    
Loop time of 672.009 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.669 hours/ns, 1.488 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.04     | 671.04     | 671.04     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15432    | 0.15432    | 0.15432    |   0.0 |  0.02
Output  | 0.00018724 | 0.00018724 | 0.00018724 |   0.0 |  0.00
Modify  | 0.71341    | 0.71341    | 0.71341    |   0.0 |  0.11
Other   |            | 0.09681    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6005 ave        6005 max        6005 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:       539328 ave      539328 max      539328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539328
Ave neighs/atom = 134.832
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 = 272.958619327109, Press = 13.7004205191809
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  -13151.428     -13151.428     -13294.172     -13294.172      276.14942      276.14942      67298.294      67298.294     -317.79649     -317.79649    
      9000  -13152.828     -13152.828     -13295.295     -13295.295      275.61249      275.61249      67288.272      67288.272     -256.96883     -256.96883    
Loop time of 670.886 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.357 hours/ns, 1.491 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.93     | 669.93     | 669.93     |   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.00018608 | 0.00018608 | 0.00018608 |   0.0 |  0.00
Modify  | 0.70364    | 0.70364    | 0.70364    |   0.0 |  0.10
Other   |            | 0.09699    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5993 ave        5993 max        5993 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:       539126 ave      539126 max      539126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539126
Ave neighs/atom = 134.7815
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 = 272.779284988758, Press = 7.77808342522814
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  -13152.828     -13152.828     -13295.295     -13295.295      275.61249      275.61249      67288.272      67288.272     -256.96883     -256.96883    
     10000  -13149.107     -13149.107     -13290.709     -13290.709      273.93847      273.93847      67298.697      67298.697     -66.677548     -66.677548    
Loop time of 673.575 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.104 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.61     | 672.61     | 672.61     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15492    | 0.15492    | 0.15492    |   0.0 |  0.02
Output  | 0.00018809 | 0.00018809 | 0.00018809 |   0.0 |  0.00
Modify  | 0.71462    | 0.71462    | 0.71462    |   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:           6001 ave        6001 max        6001 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:       539148 ave      539148 max      539148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539148
Ave neighs/atom = 134.787
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 = 272.629790058507, Press = 3.6283628357355
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  -13149.107     -13149.107     -13290.709     -13290.709      273.93847      273.93847      67298.697      67298.697     -66.677548     -66.677548    
     11000  -13154.954     -13154.954     -13295.291     -13295.291      271.49055      271.49055      67277.592      67277.592     -236.45743     -236.45743    
Loop time of 668.684 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 185.746 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.73     | 667.73     | 667.73     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15364    | 0.15364    | 0.15364    |   0.0 |  0.02
Output  | 0.0001887  | 0.0001887  | 0.0001887  |   0.0 |  0.00
Modify  | 0.70541    | 0.70541    | 0.70541    |   0.0 |  0.11
Other   |            | 0.09694    |            |       |  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:       539262 ave      539262 max      539262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539262
Ave neighs/atom = 134.8155
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 = 272.737650989146, Press = 1.9979714058776
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  -13154.954     -13154.954     -13295.291     -13295.291      271.49055      271.49055      67277.592      67277.592     -236.45743     -236.45743    
     12000  -13150.596     -13150.596     -13292.458     -13292.458      274.44076      274.44076      67300.342      67300.342     -184.10924     -184.10924    
Loop time of 671.67 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.575 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.71     | 670.71     | 670.71     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15449    | 0.15449    | 0.15449    |   0.0 |  0.02
Output  | 0.0001911  | 0.0001911  | 0.0001911  |   0.0 |  0.00
Modify  | 0.70611    | 0.70611    | 0.70611    |   0.0 |  0.11
Other   |            | 0.0967     |            |       |  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:       539184 ave      539184 max      539184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539184
Ave neighs/atom = 134.796
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 = 272.723318318643, Press = 2.48359641037217
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  -13150.596     -13150.596     -13292.458     -13292.458      274.44076      274.44076      67300.342      67300.342     -184.10924     -184.10924    
     13000  -13158.927     -13158.927     -13297.592     -13297.592      268.25753      268.25753      67277.896      67277.896     -386.14507     -386.14507    
Loop time of 670.357 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.210 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.39     | 669.39     | 669.39     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15414    | 0.15414    | 0.15414    |   0.0 |  0.02
Output  | 0.00019179 | 0.00019179 | 0.00019179 |   0.0 |  0.00
Modify  | 0.71012    | 0.71012    | 0.71012    |   0.0 |  0.11
Other   |            | 0.09772    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6001 ave        6001 max        6001 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:       539136 ave      539136 max      539136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539136
Ave neighs/atom = 134.784
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 = 272.609850906095, Press = 2.87299038932346
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  -13158.927     -13158.927     -13297.592     -13297.592      268.25753      268.25753      67277.896      67277.896     -386.14507     -386.14507    
     14000  -13150.114     -13150.114     -13291.816     -13291.816      274.13304      274.13304      67340.973      67340.973     -670.21316     -670.21316    
Loop time of 669.198 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 185.888 hours/ns, 1.494 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    | 668.23     | 668.23     | 668.23     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15454    | 0.15454    | 0.15454    |   0.0 |  0.02
Output  | 0.0014361  | 0.0014361  | 0.0014361  |   0.0 |  0.00
Modify  | 0.71097    | 0.71097    | 0.71097    |   0.0 |  0.11
Other   |            | 0.09763    |            |       |  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:       539102 ave      539102 max      539102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539102
Ave neighs/atom = 134.7755
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 = 272.602675807697, Press = 1.18596147540123
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  -13150.114     -13150.114     -13291.816     -13291.816      274.13304      274.13304      67340.973      67340.973     -670.21316     -670.21316    
     15000  -13156.657     -13156.657     -13294.536     -13294.536      266.73613      266.73613      67347.721      67347.721     -1010.0238     -1010.0238    
Loop time of 672.795 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 186.887 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.83     | 671.83     | 671.83     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15417    | 0.15417    | 0.15417    |   0.0 |  0.02
Output  | 0.00018743 | 0.00018743 | 0.00018743 |   0.0 |  0.00
Modify  | 0.70799    | 0.70799    | 0.70799    |   0.0 |  0.11
Other   |            | 0.09734    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5976 ave        5976 max        5976 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:       539084 ave      539084 max      539084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539084
Ave neighs/atom = 134.771
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 = 272.519041321546, Press = -0.783606961139576
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  -13156.657     -13156.657     -13294.536     -13294.536      266.73613      266.73613      67347.721      67347.721     -1010.0238     -1010.0238    
     16000  -13150.473     -13150.473     -13291.135     -13291.135      272.1208       272.1208       67363.653      67363.653     -884.92876     -884.92876    
Loop time of 671.803 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.612 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.85     | 670.85     | 670.85     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15272    | 0.15272    | 0.15272    |   0.0 |  0.02
Output  | 0.00023892 | 0.00023892 | 0.00023892 |   0.0 |  0.00
Modify  | 0.70506    | 0.70506    | 0.70506    |   0.0 |  0.10
Other   |            | 0.09753    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6030 ave        6030 max        6030 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:       539034 ave      539034 max      539034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539034
Ave neighs/atom = 134.7585
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 = 272.515921590578, Press = -1.50863702287417
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  -13150.473     -13150.473     -13291.135     -13291.135      272.1208       272.1208       67363.653      67363.653     -884.92876     -884.92876    
     17000  -13153.42      -13153.42      -13293.973     -13293.973      271.90941      271.90941      67293.407      67293.407     -258.07403     -258.07403    
Loop time of 674.577 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.383 hours/ns, 1.482 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.62     | 673.62     | 673.62     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15136    | 0.15136    | 0.15136    |   0.0 |  0.02
Output  | 0.00018992 | 0.00018992 | 0.00018992 |   0.0 |  0.00
Modify  | 0.70766    | 0.70766    | 0.70766    |   0.0 |  0.10
Other   |            | 0.09772    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5976 ave        5976 max        5976 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:       539012 ave      539012 max      539012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539012
Ave neighs/atom = 134.753
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 = 272.448261046423, Press = -0.38052810163302
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   
     17000  -13153.42      -13153.42      -13293.973     -13293.973      271.90941      271.90941      67293.407      67293.407     -258.07403     -258.07403    
     18000  -13150.131     -13150.131     -13292.566     -13292.566      275.55072      275.55072      67267.251      67267.251      208.52239      208.52239    
Loop time of 676.703 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.973 hours/ns, 1.478 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    | 675.73     | 675.73     | 675.73     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15425    | 0.15425    | 0.15425    |   0.0 |  0.02
Output  | 0.00019081 | 0.00019081 | 0.00019081 |   0.0 |  0.00
Modify  | 0.71794    | 0.71794    | 0.71794    |   0.0 |  0.11
Other   |            | 0.09913    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6025 ave        6025 max        6025 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:       539108 ave      539108 max      539108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539108
Ave neighs/atom = 134.777
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 = 272.434847606235, Press = -0.171355409321954
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  -13150.131     -13150.131     -13292.566     -13292.566      275.55072      275.55072      67267.251      67267.251      208.52239      208.52239    
     19000  -13148.907     -13148.907     -13290.253     -13290.253      273.44291      273.44291      67239.405      67239.405      697.20785      697.20785    
Loop time of 676.715 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.976 hours/ns, 1.478 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    | 675.74     | 675.74     | 675.74     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15538    | 0.15538    | 0.15538    |   0.0 |  0.02
Output  | 0.00019257 | 0.00019257 | 0.00019257 |   0.0 |  0.00
Modify  | 0.72211    | 0.72211    | 0.72211    |   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:           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:       539212 ave      539212 max      539212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539212
Ave neighs/atom = 134.803
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 = 272.460262458311, Press = 0.442367617422973
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  -13148.907     -13148.907     -13290.253     -13290.253      273.44291      273.44291      67239.405      67239.405      697.20785      697.20785    
     20000  -13152.427     -13152.427     -13290.426     -13290.426      266.96696      266.96696      67200.655      67200.655      1018.5404      1018.5404    
Loop time of 671.709 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.586 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.75     | 670.75     | 670.75     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15403    | 0.15403    | 0.15403    |   0.0 |  0.02
Output  | 0.00018966 | 0.00018966 | 0.00018966 |   0.0 |  0.00
Modify  | 0.70571    | 0.70571    | 0.70571    |   0.0 |  0.11
Other   |            | 0.09705    |            |       |  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:       539360 ave      539360 max      539360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539360
Ave neighs/atom = 134.84
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 = 272.630039887323, Press = 0.989771492808191
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  -13152.427     -13152.427     -13290.426     -13290.426      266.96696      266.96696      67200.655      67200.655      1018.5404      1018.5404    
     21000  -13149.202     -13149.202     -13290.932     -13290.932      274.18748      274.18748      67176.742      67176.742      1287.4525      1287.4525    
Loop time of 678.257 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.405 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.28     | 677.28     | 677.28     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15646    | 0.15646    | 0.15646    |   0.0 |  0.02
Output  | 0.00019553 | 0.00019553 | 0.00019553 |   0.0 |  0.00
Modify  | 0.71865    | 0.71865    | 0.71865    |   0.0 |  0.11
Other   |            | 0.09857    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6027 ave        6027 max        6027 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:       539338 ave      539338 max      539338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539338
Ave neighs/atom = 134.8345
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 = 272.677831774024, Press = 1.89790316168134
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  -13149.202     -13149.202     -13290.932     -13290.932      274.18748      274.18748      67176.742      67176.742      1287.4525      1287.4525    
     22000  -13153.396     -13153.396     -13293.696     -13293.696      271.41839      271.41839      67157.884      67157.884      1272.6724      1272.6724    
Loop time of 681.708 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.363 hours/ns, 1.467 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.72     | 680.72     | 680.72     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15595    | 0.15595    | 0.15595    |   0.0 |  0.02
Output  | 0.00018947 | 0.00018947 | 0.00018947 |   0.0 |  0.00
Modify  | 0.72734    | 0.72734    | 0.72734    |   0.0 |  0.11
Other   |            | 0.09926    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6041 ave        6041 max        6041 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:       539350 ave      539350 max      539350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539350
Ave neighs/atom = 134.8375
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 = 272.731958077871, Press = 2.82057078021138
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  -13153.396     -13153.396     -13293.696     -13293.696      271.41839      271.41839      67157.884      67157.884      1272.6724      1272.6724    
     23000  -13149.111     -13149.111     -13291.272     -13291.272      275.02137      275.02137      67265.109      67265.109      254.25125      254.25125    
Loop time of 680.413 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.004 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.44     | 679.44     | 679.44     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15393    | 0.15393    | 0.15393    |   0.0 |  0.02
Output  | 0.00023437 | 0.00023437 | 0.00023437 |   0.0 |  0.00
Modify  | 0.71912    | 0.71912    | 0.71912    |   0.0 |  0.11
Other   |            | 0.09883    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6014 ave        6014 max        6014 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:       539446 ave      539446 max      539446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539446
Ave neighs/atom = 134.8615
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 = 272.830417268326, Press = 1.68747837239275
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  -13149.111     -13149.111     -13291.272     -13291.272      275.02137      275.02137      67265.109      67265.109      254.25125      254.25125    
     24000  -13150.784     -13150.784     -13292.591     -13292.591      274.33455      274.33455      67293.339      67293.339     -139.09056     -139.09056    
Loop time of 675.935 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.760 hours/ns, 1.479 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.96     | 674.96     | 674.96     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15235    | 0.15235    | 0.15235    |   0.0 |  0.02
Output  | 0.00018797 | 0.00018797 | 0.00018797 |   0.0 |  0.00
Modify  | 0.71947    | 0.71947    | 0.71947    |   0.0 |  0.11
Other   |            | 0.09848    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5999 ave        5999 max        5999 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:       539376 ave      539376 max      539376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539376
Ave neighs/atom = 134.844
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 = 272.863238489871, Press = 1.54407613297791
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  -13150.784     -13150.784     -13292.591     -13292.591      274.33455      274.33455      67293.339      67293.339     -139.09056     -139.09056    
     25000  -13152.502     -13152.502     -13293.021     -13293.021      271.84266      271.84266      67305.792      67305.792     -366.02953     -366.02953    
Loop time of 679.985 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.885 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    | 679.01     | 679.01     | 679.01     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15279    | 0.15279    | 0.15279    |   0.0 |  0.02
Output  | 0.00023637 | 0.00023637 | 0.00023637 |   0.0 |  0.00
Modify  | 0.71911    | 0.71911    | 0.71911    |   0.0 |  0.11
Other   |            | 0.09853    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6015 ave        6015 max        6015 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:       539104 ave      539104 max      539104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539104
Ave neighs/atom = 134.776
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 = 272.906724893013, Press = 0.846292583418987
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  -13152.502     -13152.502     -13293.021     -13293.021      271.84266      271.84266      67305.792      67305.792     -366.02953     -366.02953    
     26000  -13148.441     -13148.441     -13291.11      -13291.11       276.00299      276.00299      67338.192      67338.192     -527.92567     -527.92567    
Loop time of 679.664 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.795 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.7      | 678.7      | 678.7      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15256    | 0.15256    | 0.15256    |   0.0 |  0.02
Output  | 0.00019082 | 0.00019082 | 0.00019082 |   0.0 |  0.00
Modify  | 0.7158     | 0.7158     | 0.7158     |   0.0 |  0.11
Other   |            | 0.09936    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5999 ave        5999 max        5999 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:       539166 ave      539166 max      539166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539166
Ave neighs/atom = 134.7915
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 = 272.914195662795, Press = 0.430958818892037
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  -13148.441     -13148.441     -13291.11      -13291.11       276.00299      276.00299      67338.192      67338.192     -527.92567     -527.92567    
     27000  -13152.669     -13152.669     -13293.298     -13293.298      272.05585      272.05585      67353.945      67353.945     -935.26999     -935.26999    
Loop time of 673.7 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.139 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.74     | 672.74     | 672.74     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15148    | 0.15148    | 0.15148    |   0.0 |  0.02
Output  | 0.00030969 | 0.00030969 | 0.00030969 |   0.0 |  0.00
Modify  | 0.71067    | 0.71067    | 0.71067    |   0.0 |  0.11
Other   |            | 0.09902    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6033 ave        6033 max        6033 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:       539012 ave      539012 max      539012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539012
Ave neighs/atom = 134.753
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 = 272.994473574451, Press = -0.576206071924513
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  -13152.669     -13152.669     -13293.298     -13293.298      272.05585      272.05585      67353.945      67353.945     -935.26999     -935.26999    
     28000  -13148.182     -13148.182     -13289.009     -13289.009      272.43869      272.43869      67347.719      67347.719     -522.02175     -522.02175    
Loop time of 676.907 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 188.030 hours/ns, 1.477 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    | 675.94     | 675.94     | 675.94     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15165    | 0.15165    | 0.15165    |   0.0 |  0.02
Output  | 0.00019055 | 0.00019055 | 0.00019055 |   0.0 |  0.00
Modify  | 0.71868    | 0.71868    | 0.71868    |   0.0 |  0.11
Other   |            | 0.09822    |            |       |  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:       539040 ave      539040 max      539040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539040
Ave neighs/atom = 134.76
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 = 273.032566389142, Press = -0.899097083863569
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  -13148.182     -13148.182     -13289.009     -13289.009      272.43869      272.43869      67347.719      67347.719     -522.02175     -522.02175    
     29000  -13154.716     -13154.716     -13293.727     -13293.727      268.92516      268.92516      67295.586      67295.586     -299.94524     -299.94524    
Loop time of 676.245 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.846 hours/ns, 1.479 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    | 675.27     | 675.27     | 675.27     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15165    | 0.15165    | 0.15165    |   0.0 |  0.02
Output  | 0.00023817 | 0.00023817 | 0.00023817 |   0.0 |  0.00
Modify  | 0.72155    | 0.72155    | 0.72155    |   0.0 |  0.11
Other   |            | 0.09893    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6000 ave        6000 max        6000 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:       539088 ave      539088 max      539088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539088
Ave neighs/atom = 134.772
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 = 273.075900265119, Press = -0.706512682020902
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  -13154.716     -13154.716     -13293.727     -13293.727      268.92516      268.92516      67295.586      67295.586     -299.94524     -299.94524    
     30000  -13150.319     -13150.319     -13291.862     -13291.862      273.82542      273.82542      67281.273      67281.273      25.074524      25.074524    
Loop time of 677.862 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.295 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.89     | 676.89     | 676.89     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15365    | 0.15365    | 0.15365    |   0.0 |  0.02
Output  | 0.00018902 | 0.00018902 | 0.00018902 |   0.0 |  0.00
Modify  | 0.7226     | 0.7226     | 0.7226     |   0.0 |  0.11
Other   |            | 0.09929    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6034 ave        6034 max        6034 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:       539250 ave      539250 max      539250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539250
Ave neighs/atom = 134.8125
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 = 273.105479363826, Press = -0.435291128217358
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  -13150.319     -13150.319     -13291.862     -13291.862      273.82542      273.82542      67281.273      67281.273      25.074524      25.074524    
     31000  -13151.309     -13151.309     -13291.755     -13291.755      271.70148      271.70148      67265.717      67265.717      179.8699       179.8699     
Loop time of 674.974 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.493 hours/ns, 1.482 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.01     | 674.01     | 674.01     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15287    | 0.15287    | 0.15287    |   0.0 |  0.02
Output  | 0.00019248 | 0.00019248 | 0.00019248 |   0.0 |  0.00
Modify  | 0.71548    | 0.71548    | 0.71548    |   0.0 |  0.11
Other   |            | 0.0982     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6015 ave        6015 max        6015 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:       539270 ave      539270 max      539270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539270
Ave neighs/atom = 134.8175
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 = 273.085576955912, Press = 0.265685804215487
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   
     31000  -13151.309     -13151.309     -13291.755     -13291.755      271.70148      271.70148      67265.717      67265.717      179.8699       179.8699     
     32000  -13158.03      -13158.03      -13298.64      -13298.64       272.01875      272.01875      67240.825      67240.825      35.296775      35.296775    
Loop time of 678.464 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.462 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.49     | 677.49     | 677.49     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15339    | 0.15339    | 0.15339    |   0.0 |  0.02
Output  | 0.00019044 | 0.00019044 | 0.00019044 |   0.0 |  0.00
Modify  | 0.7215     | 0.7215     | 0.7215     |   0.0 |  0.11
Other   |            | 0.0994     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6048 ave        6048 max        6048 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:       539390 ave      539390 max      539390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539390
Ave neighs/atom = 134.8475
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 = 273.067636978813, Press = 0.23649970291447
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   
     32000  -13158.03      -13158.03      -13298.64      -13298.64       272.01875      272.01875      67240.825      67240.825      35.296775      35.296775    
     33000  -13150.273     -13150.273     -13290.686     -13290.686      271.63867      271.63867      67262.947      67262.947      254.58658      254.58658    
Loop time of 677.615 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 188.226 hours/ns, 1.476 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.65     | 676.65     | 676.65     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15148    | 0.15148    | 0.15148    |   0.0 |  0.02
Output  | 0.00025848 | 0.00025848 | 0.00025848 |   0.0 |  0.00
Modify  | 0.7183     | 0.7183     | 0.7183     |   0.0 |  0.11
Other   |            | 0.09905    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6014 ave        6014 max        6014 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:       539166 ave      539166 max      539166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539166
Ave neighs/atom = 134.7915
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 = 273.030059784034, Press = 0.453496580325735
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   
     33000  -13150.273     -13150.273     -13290.686     -13290.686      271.63867      271.63867      67262.947      67262.947      254.58658      254.58658    
     34000  -13154.085     -13154.085     -13294.479     -13294.479      271.60218      271.60218      67229.773      67229.773      413.47646      413.47646    
Loop time of 679.195 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.665 hours/ns, 1.472 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.23     | 678.23     | 678.23     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15269    | 0.15269    | 0.15269    |   0.0 |  0.02
Output  | 0.00018956 | 0.00018956 | 0.00018956 |   0.0 |  0.00
Modify  | 0.71395    | 0.71395    | 0.71395    |   0.0 |  0.11
Other   |            | 0.09882    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6057 ave        6057 max        6057 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:       539360 ave      539360 max      539360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539360
Ave neighs/atom = 134.84
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 = 273.067106208372, Press = 0.618441718564207
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   
     34000  -13154.085     -13154.085     -13294.479     -13294.479      271.60218      271.60218      67229.773      67229.773      413.47646      413.47646    
     35000  -13152.745     -13152.745     -13292.137     -13292.137      269.66334      269.66334      67243.124      67243.124      456.81039      456.81039    
Loop time of 679.451 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.736 hours/ns, 1.472 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.48     | 678.48     | 678.48     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15137    | 0.15137    | 0.15137    |   0.0 |  0.02
Output  | 0.00018822 | 0.00018822 | 0.00018822 |   0.0 |  0.00
Modify  | 0.7254     | 0.7254     | 0.7254     |   0.0 |  0.11
Other   |            | 0.09907    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5972 ave        5972 max        5972 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:       539346 ave      539346 max      539346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539346
Ave neighs/atom = 134.8365
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 = 273.069799760791, Press = 0.944717741332002
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   
     35000  -13152.745     -13152.745     -13292.137     -13292.137      269.66334      269.66334      67243.124      67243.124      456.81039      456.81039    
     36000  -13154.951     -13154.951     -13294.534     -13294.534      270.03265      270.03265      67242.55       67242.55       282.23096      282.23096    
Loop time of 679.708 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.808 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.73     | 678.73     | 678.73     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15412    | 0.15412    | 0.15412    |   0.0 |  0.02
Output  | 0.00018713 | 0.00018713 | 0.00018713 |   0.0 |  0.00
Modify  | 0.72335    | 0.72335    | 0.72335    |   0.0 |  0.11
Other   |            | 0.09926    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6033 ave        6033 max        6033 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:       539166 ave      539166 max      539166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539166
Ave neighs/atom = 134.7915
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 = 273.104001901893, Press = 1.05600523109931
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   
     36000  -13154.951     -13154.951     -13294.534     -13294.534      270.03265      270.03265      67242.55       67242.55       282.23096      282.23096    
     37000  -13149.436     -13149.436     -13292.126     -13292.126      276.04211      276.04211      67286.997      67286.997      22.91462       22.91462     
Loop time of 682.072 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.465 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.1      | 681.1      | 681.1      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15167    | 0.15167    | 0.15167    |   0.0 |  0.02
Output  | 0.00018868 | 0.00018868 | 0.00018868 |   0.0 |  0.00
Modify  | 0.72256    | 0.72256    | 0.72256    |   0.0 |  0.11
Other   |            | 0.09918    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5979 ave        5979 max        5979 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:       539250 ave      539250 max      539250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539250
Ave neighs/atom = 134.8125
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 = 273.104833331364, Press = 1.22123964753438
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   
     37000  -13149.436     -13149.436     -13292.126     -13292.126      276.04211      276.04211      67286.997      67286.997      22.91462       22.91462     
     38000  -13154.927     -13154.927     -13293.75      -13293.75       268.56228      268.56228      67255.617      67255.617      189.12878      189.12878    
Loop time of 683.858 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 189.961 hours/ns, 1.462 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.87     | 682.87     | 682.87     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15371    | 0.15371    | 0.15371    |   0.0 |  0.02
Output  | 0.00021533 | 0.00021533 | 0.00021533 |   0.0 |  0.00
Modify  | 0.73506    | 0.73506    | 0.73506    |   0.0 |  0.11
Other   |            | 0.1005     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6047 ave        6047 max        6047 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:       539146 ave      539146 max      539146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539146
Ave neighs/atom = 134.7865
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 = 273.13304724581, Press = 1.39407139503184
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   
     38000  -13154.927     -13154.927     -13293.75      -13293.75       268.56228      268.56228      67255.617      67255.617      189.12878      189.12878    
     39000  -13151.379     -13151.379     -13293.493     -13293.493      274.92935      274.92935      67325.869      67325.869     -548.25628     -548.25628    
Loop time of 682.408 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.558 hours/ns, 1.465 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.43     | 681.43     | 681.43     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15118    | 0.15118    | 0.15118    |   0.0 |  0.02
Output  | 0.00021216 | 0.00021216 | 0.00021216 |   0.0 |  0.00
Modify  | 0.72869    | 0.72869    | 0.72869    |   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:           6003 ave        6003 max        6003 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:       539220 ave      539220 max      539220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539220
Ave neighs/atom = 134.805
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 = 273.139682788914, Press = 2.08527118342847
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   
     39000  -13151.379     -13151.379     -13293.493     -13293.493      274.92935      274.92935      67325.869      67325.869     -548.25628     -548.25628    
     40000  -13151.48      -13151.48      -13291.985     -13291.985      271.81664      271.81664      67323.665      67323.665     -468.02766     -468.02766    
Loop time of 682.724 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.645 hours/ns, 1.465 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.75     | 681.75     | 681.75     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15323    | 0.15323    | 0.15323    |   0.0 |  0.02
Output  | 0.00022302 | 0.00022302 | 0.00022302 |   0.0 |  0.00
Modify  | 0.72096    | 0.72096    | 0.72096    |   0.0 |  0.11
Other   |            | 0.09967    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6024 ave        6024 max        6024 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 = 273.127935897531, Press = 1.07136780896903
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   
     40000  -13151.48      -13151.48      -13291.985     -13291.985      271.81664      271.81664      67323.665      67323.665     -468.02766     -468.02766    
     41000  -13152.02      -13152.02      -13292.593     -13292.593      271.94686      271.94686      67303.812      67303.812     -316.00101     -316.00101    
Loop time of 676.757 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.988 hours/ns, 1.478 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    | 675.78     | 675.78     | 675.78     |   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.00030556 | 0.00030556 | 0.00030556 |   0.0 |  0.00
Modify  | 0.71936    | 0.71936    | 0.71936    |   0.0 |  0.11
Other   |            | 0.09965    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6030 ave        6030 max        6030 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 = 273.129440345673, Press = 0.756698546132121
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   
     41000  -13152.02      -13152.02      -13292.593     -13292.593      271.94686      271.94686      67303.812      67303.812     -316.00101     -316.00101    
     42000  -13149.232     -13149.232     -13295.583     -13295.583      283.12546      283.12546      67343.026      67343.026     -889.94545     -889.94545    
Loop time of 678.297 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.416 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.32     | 677.32     | 677.32     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15071    | 0.15071    | 0.15071    |   0.0 |  0.02
Output  | 0.00024015 | 0.00024015 | 0.00024015 |   0.0 |  0.00
Modify  | 0.72535    | 0.72535    | 0.72535    |   0.0 |  0.11
Other   |            | 0.09932    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5961 ave        5961 max        5961 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:       539216 ave      539216 max      539216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539216
Ave neighs/atom = 134.804
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 = 273.177737793257, Press = 0.493031713158156
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   
     42000  -13149.232     -13149.232     -13295.583     -13295.583      283.12546      283.12546      67343.026      67343.026     -889.94545     -889.94545    
     43000  -13153.195     -13153.195     -13294.438     -13294.438      273.24553      273.24553      67341.475      67341.475     -833.90159     -833.90159    
Loop time of 678.729 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.536 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.75     | 677.75     | 677.75     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15138    | 0.15138    | 0.15138    |   0.0 |  0.02
Output  | 0.00019182 | 0.00019182 | 0.00019182 |   0.0 |  0.00
Modify  | 0.72526    | 0.72526    | 0.72526    |   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:           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:       539194 ave      539194 max      539194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539194
Ave neighs/atom = 134.7985
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 = 273.173287455262, Press = 0.300147651273686
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   
     43000  -13153.195     -13153.195     -13294.438     -13294.438      273.24553      273.24553      67341.475      67341.475     -833.90159     -833.90159    
     44000  -13148.338     -13148.338     -13289.627     -13289.627      273.33252      273.33252      67432.208      67432.208     -1513.4044     -1513.4044    
Loop time of 683.867 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 189.963 hours/ns, 1.462 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.88     | 682.88     | 682.88     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15173    | 0.15173    | 0.15173    |   0.0 |  0.02
Output  | 0.00026155 | 0.00026155 | 0.00026155 |   0.0 |  0.00
Modify  | 0.73055    | 0.73055    | 0.73055    |   0.0 |  0.11
Other   |            | 0.09969    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5975 ave        5975 max        5975 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:       539120 ave      539120 max      539120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539120
Ave neighs/atom = 134.78
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 = 273.219087708468, Press = -0.447138837574073
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   
     44000  -13148.338     -13148.338     -13289.627     -13289.627      273.33252      273.33252      67432.208      67432.208     -1513.4044     -1513.4044    
     45000  -13153.028     -13153.028     -13290.96      -13290.96       266.8383       266.8383       67333.562      67333.562     -502.87672     -502.87672    
Loop time of 680.1 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.917 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.13     | 679.13     | 679.13     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1503     | 0.1503     | 0.1503     |   0.0 |  0.02
Output  | 0.00024004 | 0.00024004 | 0.00024004 |   0.0 |  0.00
Modify  | 0.71937    | 0.71937    | 0.71937    |   0.0 |  0.11
Other   |            | 0.09859    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5993 ave        5993 max        5993 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:       538874 ave      538874 max      538874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538874
Ave neighs/atom = 134.7185
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 = 273.195064803944, Press = -0.445913956985121
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   
     45000  -13153.028     -13153.028     -13290.96      -13290.96       266.8383       266.8383       67333.562      67333.562     -502.87672     -502.87672    
     46000  -13151.449     -13151.449     -13292.111     -13292.111      272.12133      272.12133      67307.025      67307.025     -271.03804     -271.03804    
Loop time of 682.867 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.685 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    | 681.88     | 681.88     | 681.88     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15084    | 0.15084    | 0.15084    |   0.0 |  0.02
Output  | 0.00019356 | 0.00019356 | 0.00019356 |   0.0 |  0.00
Modify  | 0.73027    | 0.73027    | 0.73027    |   0.0 |  0.11
Other   |            | 0.101      |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5974 ave        5974 max        5974 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 = 273.203634843513, Press = -0.490094484171509
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   
     46000  -13151.449     -13151.449     -13292.111     -13292.111      272.12133      272.12133      67307.025      67307.025     -271.03804     -271.03804    
     47000  -13146.79      -13146.79      -13290.316     -13290.316      277.66181      277.66181      67298.797      67298.797     -32.241223     -32.241223    
Loop time of 682.341 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.539 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.37     | 681.37     | 681.37     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15308    | 0.15308    | 0.15308    |   0.0 |  0.02
Output  | 0.00018857 | 0.00018857 | 0.00018857 |   0.0 |  0.00
Modify  | 0.72417    | 0.72417    | 0.72417    |   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:           6032 ave        6032 max        6032 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:       539108 ave      539108 max      539108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539108
Ave neighs/atom = 134.777
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 = 273.200226668574, Press = -0.287430148165927
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   
     47000  -13146.79      -13146.79      -13290.316     -13290.316      277.66181      277.66181      67298.797      67298.797     -32.241223     -32.241223    
     48000  -13153.646     -13153.646     -13293.855     -13293.855      271.24399      271.24399      67250.485      67250.485      238.02783      238.02783    
Loop time of 686.794 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 685.81     | 685.81     | 685.81     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15212    | 0.15212    | 0.15212    |   0.0 |  0.02
Output  | 0.00019603 | 0.00019603 | 0.00019603 |   0.0 |  0.00
Modify  | 0.73094    | 0.73094    | 0.73094    |   0.0 |  0.11
Other   |            | 0.0999     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5986 ave        5986 max        5986 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:       539150 ave      539150 max      539150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539150
Ave neighs/atom = 134.7875
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 = 273.247401021679, Press = -0.24101853013799
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   
     48000  -13153.646     -13153.646     -13293.855     -13293.855      271.24399      271.24399      67250.485      67250.485      238.02783      238.02783    
     49000  -13147.735     -13147.735     -13290.053     -13290.053      275.32395      275.32395      67262.73       67262.73       423.35273      423.35273    
Loop time of 681.235 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.232 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.27     | 680.27     | 680.27     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15027    | 0.15027    | 0.15027    |   0.0 |  0.02
Output  | 0.00019298 | 0.00019298 | 0.00019298 |   0.0 |  0.00
Modify  | 0.71779    | 0.71779    | 0.71779    |   0.0 |  0.11
Other   |            | 0.09862    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5963 ave        5963 max        5963 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:       539236 ave      539236 max      539236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539236
Ave neighs/atom = 134.809
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 = 273.255715342628, Press = -0.312943745371986
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   
     49000  -13147.735     -13147.735     -13290.053     -13290.053      275.32395      275.32395      67262.73       67262.73       423.35273      423.35273    
     50000  -13153.26      -13153.26      -13295.224     -13295.224      274.6388       274.6388       67222.595      67222.595      478.5516       478.5516     
Loop time of 674.758 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.433 hours/ns, 1.482 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.79     | 673.79     | 673.79     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15231    | 0.15231    | 0.15231    |   0.0 |  0.02
Output  | 0.00018956 | 0.00018956 | 0.00018956 |   0.0 |  0.00
Modify  | 0.71451    | 0.71451    | 0.71451    |   0.0 |  0.11
Other   |            | 0.09848    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6032 ave        6032 max        6032 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:       539206 ave      539206 max      539206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539206
Ave neighs/atom = 134.8015
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 = 273.27591331904, Press = -0.80062690287969
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   
     50000  -13153.26      -13153.26      -13295.224     -13295.224      274.6388       274.6388       67222.595      67222.595      478.5516       478.5516     
     51000  -13152.075     -13152.075     -13294.587     -13294.587      275.70029      275.70029      67214.65       67214.65       638.09856      638.09856    
Loop time of 674.871 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.464 hours/ns, 1.482 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.91     | 673.91     | 673.91     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15194    | 0.15194    | 0.15194    |   0.0 |  0.02
Output  | 0.00019213 | 0.00019213 | 0.00019213 |   0.0 |  0.00
Modify  | 0.70944    | 0.70944    | 0.70944    |   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:           6047 ave        6047 max        6047 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:       539340 ave      539340 max      539340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539340
Ave neighs/atom = 134.835
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 = 273.267357726647, Press = -0.462432782228989
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   
     51000  -13152.075     -13152.075     -13294.587     -13294.587      275.70029      275.70029      67214.65       67214.65       638.09856      638.09856    
     52000  -13151.372     -13151.372     -13290.886     -13290.886      269.89977      269.89977      67239.044      67239.044      563.64453      563.64453    
Loop time of 671.955 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.654 hours/ns, 1.488 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        | 671        | 671        |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14979    | 0.14979    | 0.14979    |   0.0 |  0.02
Output  | 0.00019213 | 0.00019213 | 0.00019213 |   0.0 |  0.00
Modify  | 0.71179    | 0.71179    | 0.71179    |   0.0 |  0.11
Other   |            | 0.098      |            |       |  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:       539334 ave      539334 max      539334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539334
Ave neighs/atom = 134.8335
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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
67275.6963816749

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0