# 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.006 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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  -13267.791     -13267.791     -13440         -13440          333.15         333.15         66167.252      66167.252      2779.9187      2779.9187    
      1000  -13075.359     -13075.359     -13255.181     -13255.181      347.8789       347.8789       67709.656      67709.656     -1536.5072     -1536.5072    
Loop time of 651.105 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.862 hours/ns, 1.536 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    | 650.18     | 650.18     | 650.18     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14915    | 0.14915    | 0.14915    |   0.0 |  0.02
Output  | 0.00035198 | 0.00035198 | 0.00035198 |   0.0 |  0.00
Modify  | 0.67804    | 0.67804    | 0.67804    |   0.0 |  0.10
Other   |            | 0.09678    |            |       |  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  -13075.359     -13075.359     -13255.181     -13255.181      347.8789       347.8789       67709.656      67709.656     -1536.5072     -1536.5072    
      2000  -13094.787     -13094.787     -13266.546     -13266.546      332.27821      332.27821      67471.612      67471.612      217.77062      217.77062    
Loop time of 670.724 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.312 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.8      | 669.8      | 669.8      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15255    | 0.15255    | 0.15255    |   0.0 |  0.02
Output  | 0.00023268 | 0.00023268 | 0.00023268 |   0.0 |  0.00
Modify  | 0.67746    | 0.67746    | 0.67746    |   0.0 |  0.10
Other   |            | 0.09703    |            |       |  0.01

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

Total # of neighbors = 538474
Ave neighs/atom = 134.6185
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  -13094.787     -13094.787     -13266.546     -13266.546      332.27821      332.27821      67471.612      67471.612      217.77062      217.77062    
      3000  -13081.184     -13081.184     -13252.35      -13252.35       331.13171      331.13171      67555.778      67555.778      226.5324       226.5324     
Loop time of 673.893 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.192 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.96     | 672.96     | 672.96     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15399    | 0.15399    | 0.15399    |   0.0 |  0.02
Output  | 0.00023272 | 0.00023272 | 0.00023272 |   0.0 |  0.00
Modify  | 0.68069    | 0.68069    | 0.68069    |   0.0 |  0.10
Other   |            | 0.09742    |            |       |  0.01

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

Total # of neighbors = 538952
Ave neighs/atom = 134.738
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  -13081.184     -13081.184     -13252.35      -13252.35       331.13171      331.13171      67555.778      67555.778      226.5324       226.5324     
      4000  -13091.557     -13091.557     -13261.588     -13261.588      328.93541      328.93541      67536.578      67536.578     -235.0801      -235.0801     
Loop time of 670.211 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.170 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.28     | 669.28     | 669.28     |   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.00022899 | 0.00022899 | 0.00022899 |   0.0 |  0.00
Modify  | 0.67805    | 0.67805    | 0.67805    |   0.0 |  0.10
Other   |            | 0.09683    |            |       |  0.01

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

Total # of neighbors = 538780
Ave neighs/atom = 134.695
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  -13091.557     -13091.557     -13261.588     -13261.588      328.93541      328.93541      67536.578      67536.578     -235.0801      -235.0801     
      5000  -13085.454     -13085.454     -13259.453     -13259.453      336.61235      336.61235      67526.099      67526.099      52.386837      52.386837    
Loop time of 672.564 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 186.823 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.63     | 671.63     | 671.63     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15206    | 0.15206    | 0.15206    |   0.0 |  0.02
Output  | 0.00018958 | 0.00018958 | 0.00018958 |   0.0 |  0.00
Modify  | 0.68165    | 0.68165    | 0.68165    |   0.0 |  0.10
Other   |            | 0.09726    |            |       |  0.01

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

Total # of neighbors = 538842
Ave neighs/atom = 134.7105
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 = 338.060472941296, Press = -157.456928633048
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  -13085.454     -13085.454     -13259.453     -13259.453      336.61235      336.61235      67526.099      67526.099      52.386837      52.386837    
      6000  -13087.075     -13087.075     -13259.941     -13259.941      334.42212      334.42212      67568.171      67568.171     -435.75873     -435.75873    
Loop time of 670.342 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.206 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.15192    | 0.15192    | 0.15192    |   0.0 |  0.02
Output  | 0.00019755 | 0.00019755 | 0.00019755 |   0.0 |  0.00
Modify  | 0.70292    | 0.70292    | 0.70292    |   0.0 |  0.10
Other   |            | 0.09666    |            |       |  0.01

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

Total # of neighbors = 538916
Ave neighs/atom = 134.729
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 = 332.721317510889, Press = 15.0149502925428
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  -13087.075     -13087.075     -13259.941     -13259.941      334.42212      334.42212      67568.171      67568.171     -435.75873     -435.75873    
      7000  -13088.344     -13088.344     -13260.093     -13260.093      332.25964      332.25964      67444.71       67444.71       906.03167      906.03167    
Loop time of 671.445 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.512 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.49     | 670.49     | 670.49     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15367    | 0.15367    | 0.15367    |   0.0 |  0.02
Output  | 0.00018701 | 0.00018701 | 0.00018701 |   0.0 |  0.00
Modify  | 0.70495    | 0.70495    | 0.70495    |   0.0 |  0.10
Other   |            | 0.09722    |            |       |  0.01

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

Total # of neighbors = 538800
Ave neighs/atom = 134.7
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 = 333.207552267588, Press = -19.9538937369558
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  -13088.344     -13088.344     -13260.093     -13260.093      332.25964      332.25964      67444.71       67444.71       906.03167      906.03167    
      8000  -13087.19      -13087.19      -13255.991     -13255.991      326.55662      326.55662      67668.77       67668.77      -1396.384      -1396.384     
Loop time of 673.89 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.192 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.93     | 672.93     | 672.93     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15301    | 0.15301    | 0.15301    |   0.0 |  0.02
Output  | 0.00022914 | 0.00022914 | 0.00022914 |   0.0 |  0.00
Modify  | 0.70721    | 0.70721    | 0.70721    |   0.0 |  0.10
Other   |            | 0.09745    |            |       |  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:       538970 ave      538970 max      538970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538970
Ave neighs/atom = 134.7425
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 = 332.928826588943, Press = 6.32043836788717
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  -13087.19      -13087.19      -13255.991     -13255.991      326.55662      326.55662      67668.77       67668.77      -1396.384      -1396.384     
      9000  -13091.307     -13091.307     -13260.989     -13260.989      328.2626       328.2626       67431.108      67431.108      935.11521      935.11521    
Loop time of 671.985 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.662 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.02     | 671.02     | 671.02     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15419    | 0.15419    | 0.15419    |   0.0 |  0.02
Output  | 0.00018969 | 0.00018969 | 0.00018969 |   0.0 |  0.00
Modify  | 0.71021    | 0.71021    | 0.71021    |   0.0 |  0.11
Other   |            | 0.09683    |            |       |  0.01

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

Total # of neighbors = 538556
Ave neighs/atom = 134.639
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 = 332.689062368131, Press = -1.15741505278142
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  -13091.307     -13091.307     -13260.989     -13260.989      328.2626       328.2626       67431.108      67431.108      935.11521      935.11521    
     10000  -13087.459     -13087.459     -13260.117     -13260.117      334.0183       334.0183       67587.696      67587.696     -748.5011      -748.5011     
Loop time of 672.28 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.744 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.33     | 671.33     | 671.33     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15195    | 0.15195    | 0.15195    |   0.0 |  0.02
Output  | 0.00018932 | 0.00018932 | 0.00018932 |   0.0 |  0.00
Modify  | 0.70385    | 0.70385    | 0.70385    |   0.0 |  0.10
Other   |            | 0.09687    |            |       |  0.01

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

Total # of neighbors = 539246
Ave neighs/atom = 134.8115
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 = 332.381908870521, Press = -1.19314088302294
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  -13087.459     -13087.459     -13260.117     -13260.117      334.0183       334.0183       67587.696      67587.696     -748.5011      -748.5011     
     11000  -13088.606     -13088.606     -13259.46      -13259.46       330.52881      330.52881      67498.625      67498.625      393.51278      393.51278    
Loop time of 671.17 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.436 hours/ns, 1.490 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.21     | 670.21     | 670.21     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15375    | 0.15375    | 0.15375    |   0.0 |  0.02
Output  | 0.00019472 | 0.00019472 | 0.00019472 |   0.0 |  0.00
Modify  | 0.70729    | 0.70729    | 0.70729    |   0.0 |  0.11
Other   |            | 0.09752    |            |       |  0.01

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

Total # of neighbors = 538804
Ave neighs/atom = 134.701
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 = 332.542156070711, Press = 0.595341789928009
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  -13088.606     -13088.606     -13259.46      -13259.46       330.52881      330.52881      67498.625      67498.625      393.51278      393.51278    
     12000  -13090.591     -13090.591     -13260.642     -13260.642      328.9751       328.9751       67566.93       67566.93      -490.39067     -490.39067    
Loop time of 677.035 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 188.065 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    | 676.06     | 676.06     | 676.06     |   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.00018881 | 0.00018881 | 0.00018881 |   0.0 |  0.00
Modify  | 0.72087    | 0.72087    | 0.72087    |   0.0 |  0.11
Other   |            | 0.09868    |            |       |  0.01

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

Total # of neighbors = 538820
Ave neighs/atom = 134.705
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 = 332.28700867291, Press = -1.18109629302474
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  -13090.591     -13090.591     -13260.642     -13260.642      328.9751       328.9751       67566.93       67566.93      -490.39067     -490.39067    
     13000  -13081.773     -13081.773     -13258.592     -13258.592      342.06933      342.06933      67463.058      67463.058      912.46508      912.46508    
Loop time of 672.411 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 186.781 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.45     | 671.45     | 671.45     |   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.00018825 | 0.00018825 | 0.00018825 |   0.0 |  0.00
Modify  | 0.70823    | 0.70823    | 0.70823    |   0.0 |  0.11
Other   |            | 0.09654    |            |       |  0.01

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

Total # of neighbors = 538742
Ave neighs/atom = 134.6855
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 = 332.376008871624, Press = 3.33053448395361
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  -13081.773     -13081.773     -13258.592     -13258.592      342.06933      342.06933      67463.058      67463.058      912.46508      912.46508    
     14000  -13086.162     -13086.162     -13259.017     -13259.017      334.4009       334.4009       67609.289      67609.289     -827.8821      -827.8821     
Loop time of 670.862 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.351 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.91     | 669.91     | 669.91     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15297    | 0.15297    | 0.15297    |   0.0 |  0.02
Output  | 0.00045539 | 0.00045539 | 0.00045539 |   0.0 |  0.00
Modify  | 0.70435    | 0.70435    | 0.70435    |   0.0 |  0.10
Other   |            | 0.09682    |            |       |  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:       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 = 332.480547330863, Press = -5.38873803609055
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  -13086.162     -13086.162     -13259.017     -13259.017      334.4009       334.4009       67609.289      67609.289     -827.8821      -827.8821     
     15000  -13087.976     -13087.976     -13257.494     -13257.494      327.94509      327.94509      67532.607      67532.607      31.39685       31.39685     
Loop time of 674.133 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.259 hours/ns, 1.483 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 673.17     | 673.17     | 673.17     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15169    | 0.15169    | 0.15169    |   0.0 |  0.02
Output  | 0.00023559 | 0.00023559 | 0.00023559 |   0.0 |  0.00
Modify  | 0.71007    | 0.71007    | 0.71007    |   0.0 |  0.11
Other   |            | 0.09806    |            |       |  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:       538738 ave      538738 max      538738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538738
Ave neighs/atom = 134.6845
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 = 332.692044712404, Press = 2.70980408400607
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  -13087.976     -13087.976     -13257.494     -13257.494      327.94509      327.94509      67532.607      67532.607      31.39685       31.39685     
     16000  -13092.077     -13092.077     -13262.36      -13262.36       329.42352      329.42352      67459.698      67459.698      593.19748      593.19748    
Loop time of 674.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.291 hours/ns, 1.483 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 673.28     | 673.28     | 673.28     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1543     | 0.1543     | 0.1543     |   0.0 |  0.02
Output  | 0.00018778 | 0.00018778 | 0.00018778 |   0.0 |  0.00
Modify  | 0.71103    | 0.71103    | 0.71103    |   0.0 |  0.11
Other   |            | 0.09706    |            |       |  0.01

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

Total # of neighbors = 538902
Ave neighs/atom = 134.7255
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 = 332.60491072686, Press = -1.11204119213175
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  -13092.077     -13092.077     -13262.36      -13262.36       329.42352      329.42352      67459.698      67459.698      593.19748      593.19748    
     17000  -13085.163     -13085.163     -13256.573     -13256.573      331.6038       331.6038       67583.139      67583.139     -351.4561      -351.4561     
Loop time of 677.195 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 188.110 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    | 676.23     | 676.23     | 676.23     |   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.00029485 | 0.00029485 | 0.00029485 |   0.0 |  0.00
Modify  | 0.71136    | 0.71136    | 0.71136    |   0.0 |  0.11
Other   |            | 0.09648    |            |       |  0.01

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

Total # of neighbors = 538940
Ave neighs/atom = 134.735
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 = 332.567697173985, Press = -0.185225964635797
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  -13085.163     -13085.163     -13256.573     -13256.573      331.6038       331.6038       67583.139      67583.139     -351.4561      -351.4561     
     18000  -13089.518     -13089.518     -13260.738     -13260.738      331.23606      331.23606      67435.761      67435.761      1029.0777      1029.0777    
Loop time of 675.193 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.554 hours/ns, 1.481 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 674.23     | 674.23     | 674.23     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15434    | 0.15434    | 0.15434    |   0.0 |  0.02
Output  | 0.00018986 | 0.00018986 | 0.00018986 |   0.0 |  0.00
Modify  | 0.71564    | 0.71564    | 0.71564    |   0.0 |  0.11
Other   |            | 0.09738    |            |       |  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:       538790 ave      538790 max      538790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538790
Ave neighs/atom = 134.6975
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 = 332.456798375325, Press = 0.286737347651358
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  -13089.518     -13089.518     -13260.738     -13260.738      331.23606      331.23606      67435.761      67435.761      1029.0777      1029.0777    
     19000  -13085.205     -13085.205     -13258.327     -13258.327      334.91733      334.91733      67676.124      67676.124     -1516.81       -1516.81      
Loop time of 678.98 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.606 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    | 678.01     | 678.01     | 678.01     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15359    | 0.15359    | 0.15359    |   0.0 |  0.02
Output  | 0.00018862 | 0.00018862 | 0.00018862 |   0.0 |  0.00
Modify  | 0.7181     | 0.7181     | 0.7181     |   0.0 |  0.11
Other   |            | 0.09747    |            |       |  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:       539080 ave      539080 max      539080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539080
Ave neighs/atom = 134.77
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 = 332.393089987268, Press = -2.15738730289117
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  -13085.205     -13085.205     -13258.327     -13258.327      334.91733      334.91733      67676.124      67676.124     -1516.81       -1516.81      
     20000  -13089.803     -13089.803     -13259.805     -13259.805      328.88104      328.88104      67443.385      67443.385      933.42441      933.42441    
Loop time of 676.593 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.942 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.63     | 675.63     | 675.63     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15254    | 0.15254    | 0.15254    |   0.0 |  0.02
Output  | 0.00018713 | 0.00018713 | 0.00018713 |   0.0 |  0.00
Modify  | 0.71607    | 0.71607    | 0.71607    |   0.0 |  0.11
Other   |            | 0.09733    |            |       |  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:       538406 ave      538406 max      538406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538406
Ave neighs/atom = 134.6015
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 = 332.319532249317, Press = 2.16755081651098
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  -13089.803     -13089.803     -13259.805     -13259.805      328.88104      328.88104      67443.385      67443.385      933.42441      933.42441    
     21000  -13090.22      -13090.22      -13261.267     -13261.267      330.90303      330.90303      67534.643      67534.643     -204.35789     -204.35789    
Loop time of 680.915 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.143 hours/ns, 1.469 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.94     | 679.94     | 679.94     |   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.00018677 | 0.00018677 | 0.00018677 |   0.0 |  0.00
Modify  | 0.72589    | 0.72589    | 0.72589    |   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:           5996 ave        5996 max        5996 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       539134 ave      539134 max      539134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539134
Ave neighs/atom = 134.7835
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 = 332.358218862746, Press = -1.69228764704306
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13090.22      -13090.22      -13261.267     -13261.267      330.90303      330.90303      67534.643      67534.643     -204.35789     -204.35789    
     22000  -13083.041     -13083.041     -13254.747     -13254.747      332.17546      332.17546      67545.859      67545.859      107.11749      107.11749    
Loop time of 684.406 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 190.113 hours/ns, 1.461 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    | 683.42     | 683.42     | 683.42     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15546    | 0.15546    | 0.15546    |   0.0 |  0.02
Output  | 0.00023143 | 0.00023143 | 0.00023143 |   0.0 |  0.00
Modify  | 0.72989    | 0.72989    | 0.72989    |   0.0 |  0.11
Other   |            | 0.09855    |            |       |  0.01

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

Total # of neighbors = 538854
Ave neighs/atom = 134.7135
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 = 332.498363699417, Press = 0.25725000337458
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  -13083.041     -13083.041     -13254.747     -13254.747      332.17546      332.17546      67545.859      67545.859      107.11749      107.11749    
     23000  -13087.198     -13087.198     -13260.361     -13260.361      334.99618      334.99618      67514.891      67514.891      124.53358      124.53358    
Loop time of 683.058 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 682.08     | 682.08     | 682.08     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15249    | 0.15249    | 0.15249    |   0.0 |  0.02
Output  | 0.00018706 | 0.00018706 | 0.00018706 |   0.0 |  0.00
Modify  | 0.72868    | 0.72868    | 0.72868    |   0.0 |  0.11
Other   |            | 0.09823    |            |       |  0.01

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

Total # of neighbors = 538924
Ave neighs/atom = 134.731
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 = 332.596311922, Press = -0.82824245437137
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  -13087.198     -13087.198     -13260.361     -13260.361      334.99618      334.99618      67514.891      67514.891      124.53358      124.53358    
     24000  -13087.686     -13087.686     -13259.587     -13259.587      332.55301      332.55301      67576.92       67576.92      -475.86337     -475.86337    
Loop time of 682.355 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.543 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.39     | 681.39     | 681.39     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15206    | 0.15206    | 0.15206    |   0.0 |  0.02
Output  | 0.00023017 | 0.00023017 | 0.00023017 |   0.0 |  0.00
Modify  | 0.71966    | 0.71966    | 0.71966    |   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:           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:       538846 ave      538846 max      538846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538846
Ave neighs/atom = 134.7115
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 = 332.7236377926, Press = 0.803898346956817
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  -13087.686     -13087.686     -13259.587     -13259.587      332.55301      332.55301      67576.92       67576.92      -475.86337     -475.86337    
     25000  -13084.607     -13084.607     -13257.602     -13257.602      334.67183      334.67183      67454.675      67454.675      1022.7923      1022.7923    
Loop time of 679.309 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.697 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.34     | 678.34     | 678.34     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15098    | 0.15098    | 0.15098    |   0.0 |  0.02
Output  | 0.00029622 | 0.00029622 | 0.00029622 |   0.0 |  0.00
Modify  | 0.71598    | 0.71598    | 0.71598    |   0.0 |  0.11
Other   |            | 0.09728    |            |       |  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:       538790 ave      538790 max      538790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538790
Ave neighs/atom = 134.6975
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 = 332.710043496887, Press = -1.15202495653751
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  -13084.607     -13084.607     -13257.602     -13257.602      334.67183      334.67183      67454.675      67454.675      1022.7923      1022.7923    
     26000  -13086.81      -13086.81      -13257.386     -13257.386      329.99056      329.99056      67654.808      67654.808     -1205.8915     -1205.8915    
Loop time of 680.886 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.135 hours/ns, 1.469 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.92     | 679.92     | 679.92     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15357    | 0.15357    | 0.15357    |   0.0 |  0.02
Output  | 0.0001873  | 0.0001873  | 0.0001873  |   0.0 |  0.00
Modify  | 0.71907    | 0.71907    | 0.71907    |   0.0 |  0.11
Other   |            | 0.09698    |            |       |  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:       539118 ave      539118 max      539118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539118
Ave neighs/atom = 134.7795
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 = 332.737466805562, Press = -0.322128376783566
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  -13086.81      -13086.81      -13257.386     -13257.386      329.99056      329.99056      67654.808      67654.808     -1205.8915     -1205.8915    
     27000  -13087.405     -13087.405     -13260.869     -13260.869      335.57909      335.57909      67421.771      67421.771      1158.6146      1158.6146    
Loop time of 676.813 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 188.004 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.85     | 675.85     | 675.85     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15163    | 0.15163    | 0.15163    |   0.0 |  0.02
Output  | 0.00018921 | 0.00018921 | 0.00018921 |   0.0 |  0.00
Modify  | 0.71602    | 0.71602    | 0.71602    |   0.0 |  0.11
Other   |            | 0.09777    |            |       |  0.01

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

Total # of neighbors = 538654
Ave neighs/atom = 134.6635
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 = 332.659073872048, Press = 0.125562457151147
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  -13087.405     -13087.405     -13260.869     -13260.869      335.57909      335.57909      67421.771      67421.771      1158.6146      1158.6146    
     28000  -13087.056     -13087.056     -13259.597     -13259.597      333.79314      333.79314      67578.578      67578.578     -567.57432     -567.57432    
Loop time of 677.746 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.263 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.78     | 676.78     | 676.78     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15146    | 0.15146    | 0.15146    |   0.0 |  0.02
Output  | 0.0002372  | 0.0002372  | 0.0002372  |   0.0 |  0.00
Modify  | 0.71429    | 0.71429    | 0.71429    |   0.0 |  0.11
Other   |            | 0.09776    |            |       |  0.01

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

Total # of neighbors = 539122
Ave neighs/atom = 134.7805
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 = 332.696316628763, Press = -0.398598843167034
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  -13087.056     -13087.056     -13259.597     -13259.597      333.79314      333.79314      67578.578      67578.578     -567.57432     -567.57432    
     29000  -13093.224     -13093.224     -13263.235     -13263.235      328.89918      328.89918      67485.556      67485.556      179.35721      179.35721    
Loop time of 679.302 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.695 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.33     | 678.33     | 678.33     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15428    | 0.15428    | 0.15428    |   0.0 |  0.02
Output  | 0.00018679 | 0.00018679 | 0.00018679 |   0.0 |  0.00
Modify  | 0.72203    | 0.72203    | 0.72203    |   0.0 |  0.11
Other   |            | 0.09837    |            |       |  0.01

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

Total # of neighbors = 538792
Ave neighs/atom = 134.698
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 = 332.623913556686, Press = 0.306803483709782
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  -13093.224     -13093.224     -13263.235     -13263.235      328.89918      328.89918      67485.556      67485.556      179.35721      179.35721    
     30000  -13089.717     -13089.717     -13258.667     -13258.667      326.84525      326.84525      67515.55       67515.55       179.9768       179.9768     
Loop time of 676.49 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.914 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.53     | 675.53     | 675.53     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15089    | 0.15089    | 0.15089    |   0.0 |  0.02
Output  | 0.00018996 | 0.00018996 | 0.00018996 |   0.0 |  0.00
Modify  | 0.71396    | 0.71396    | 0.71396    |   0.0 |  0.11
Other   |            | 0.09773    |            |       |  0.01

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

Total # of neighbors = 539130
Ave neighs/atom = 134.7825
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 = 332.651768855585, Press = -0.539768623964979
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  -13089.717     -13089.717     -13258.667     -13258.667      326.84525      326.84525      67515.55       67515.55       179.9768       179.9768     
     31000  -13084.885     -13084.885     -13257.018     -13257.018      333.00272      333.00272      67547.772      67547.772     -21.668973     -21.668973    
Loop time of 680.083 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.912 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.12     | 679.12     | 679.12     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15234    | 0.15234    | 0.15234    |   0.0 |  0.02
Output  | 0.00023635 | 0.00023635 | 0.00023635 |   0.0 |  0.00
Modify  | 0.71616    | 0.71616    | 0.71616    |   0.0 |  0.11
Other   |            | 0.09702    |            |       |  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:       538972 ave      538972 max      538972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538972
Ave neighs/atom = 134.743
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 = 332.610500476021, Press = 0.24927161173471
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  -13084.885     -13084.885     -13257.018     -13257.018      333.00272      333.00272      67547.772      67547.772     -21.668973     -21.668973    
     32000  -13085.918     -13085.918     -13259.361     -13259.361      335.53692      335.53692      67533.685      67533.685      12.485782      12.485782    
Loop time of 675.539 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.650 hours/ns, 1.480 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 674.58     | 674.58     | 674.58     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14984    | 0.14984    | 0.14984    |   0.0 |  0.02
Output  | 0.00018954 | 0.00018954 | 0.00018954 |   0.0 |  0.00
Modify  | 0.70952    | 0.70952    | 0.70952    |   0.0 |  0.11
Other   |            | 0.09724    |            |       |  0.01

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

Total # of neighbors = 538952
Ave neighs/atom = 134.738
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 = 332.563645171987, Press = -0.58408788876664
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  -13085.918     -13085.918     -13259.361     -13259.361      335.53692      335.53692      67533.685      67533.685      12.485782      12.485782    
     33000  -13092.093     -13092.093     -13260.794     -13260.794      326.36407      326.36407      67511.956      67511.956      92.960383      92.960383    
Loop time of 679.544 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.762 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.57     | 678.57     | 678.57     |   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.00023172 | 0.00023172 | 0.00023172 |   0.0 |  0.00
Modify  | 0.71912    | 0.71912    | 0.71912    |   0.0 |  0.11
Other   |            | 0.09866    |            |       |  0.01

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

Total # of neighbors = 538848
Ave neighs/atom = 134.712
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 = 332.543729729707, Press = -0.262317203811532
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  -13092.093     -13092.093     -13260.794     -13260.794      326.36407      326.36407      67511.956      67511.956      92.960383      92.960383    
     34000  -13083.721     -13083.721     -13257.345     -13257.345      335.88786      335.88786      67541.116      67541.116      135.54022      135.54022    
Loop time of 676.583 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.940 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.62     | 675.62     | 675.62     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15018    | 0.15018    | 0.15018    |   0.0 |  0.02
Output  | 0.00025779 | 0.00025779 | 0.00025779 |   0.0 |  0.00
Modify  | 0.71309    | 0.71309    | 0.71309    |   0.0 |  0.11
Other   |            | 0.09769    |            |       |  0.01

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

Total # of neighbors = 538980
Ave neighs/atom = 134.745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.514161743632, Press = -0.35577255359845
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  -13083.721     -13083.721     -13257.345     -13257.345      335.88786      335.88786      67541.116      67541.116      135.54022      135.54022    
     35000  -13092.406     -13092.406     -13263.103     -13263.103      330.22459      330.22459      67543.747      67543.747     -376.43133     -376.43133    
Loop time of 684.45 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 190.125 hours/ns, 1.461 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    | 683.47     | 683.47     | 683.47     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15233    | 0.15233    | 0.15233    |   0.0 |  0.02
Output  | 0.00018616 | 0.00018616 | 0.00018616 |   0.0 |  0.00
Modify  | 0.7268     | 0.7268     | 0.7268     |   0.0 |  0.11
Other   |            | 0.0985     |            |       |  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:       538756 ave      538756 max      538756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538756
Ave neighs/atom = 134.689
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 = 332.478456272445, Press = 0.330955360900784
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  -13092.406     -13092.406     -13263.103     -13263.103      330.22459      330.22459      67543.747      67543.747     -376.43133     -376.43133    
     36000  -13085.541     -13085.541     -13259.578     -13259.578      336.68631      336.68631      67476.378      67476.378      667.51583      667.51583    
Loop time of 685.243 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 190.345 hours/ns, 1.459 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    | 684.26     | 684.26     | 684.26     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15265    | 0.15265    | 0.15265    |   0.0 |  0.02
Output  | 0.00028679 | 0.00028679 | 0.00028679 |   0.0 |  0.00
Modify  | 0.72641    | 0.72641    | 0.72641    |   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:           6006 ave        6006 max        6006 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538958 ave      538958 max      538958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538958
Ave neighs/atom = 134.7395
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 = 332.467540242752, Press = -0.276250285902621
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  -13085.541     -13085.541     -13259.578     -13259.578      336.68631      336.68631      67476.378      67476.378      667.51583      667.51583    
     37000  -13082.505     -13082.505     -13255.714     -13255.714      335.08609      335.08609      67646.184      67646.184     -1027.3806     -1027.3806    
Loop time of 677.714 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.254 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.75     | 676.75     | 676.75     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15057    | 0.15057    | 0.15057    |   0.0 |  0.02
Output  | 0.00018876 | 0.00018876 | 0.00018876 |   0.0 |  0.00
Modify  | 0.71431    | 0.71431    | 0.71431    |   0.0 |  0.11
Other   |            | 0.0971     |            |       |  0.01

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

Total # of neighbors = 538976
Ave neighs/atom = 134.744
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 = 332.45663210209, Press = -0.568261052703136
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  -13082.505     -13082.505     -13255.714     -13255.714      335.08609      335.08609      67646.184      67646.184     -1027.3806     -1027.3806    
     38000  -13087.764     -13087.764     -13263.877     -13263.877      340.70267      340.70267      67432.155      67432.155      821.44344      821.44344    
Loop time of 685.287 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 190.357 hours/ns, 1.459 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    | 684.31     | 684.31     | 684.31     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15315    | 0.15315    | 0.15315    |   0.0 |  0.02
Output  | 0.00019585 | 0.00019585 | 0.00019585 |   0.0 |  0.00
Modify  | 0.72624    | 0.72624    | 0.72624    |   0.0 |  0.11
Other   |            | 0.09832    |            |       |  0.01

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

Total # of neighbors = 538576
Ave neighs/atom = 134.644
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 = 332.534770015894, Press = 0.61956050232027
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  -13087.764     -13087.764     -13263.877     -13263.877      340.70267      340.70267      67432.155      67432.155      821.44344      821.44344    
     39000  -13082.086     -13082.086     -13257.503     -13257.503      339.35613      339.35613      67627.927      67627.927     -899.49534     -899.49534    
Loop time of 683.31 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 189.808 hours/ns, 1.463 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.34     | 682.34     | 682.34     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15221    | 0.15221    | 0.15221    |   0.0 |  0.02
Output  | 0.0001922  | 0.0001922  | 0.0001922  |   0.0 |  0.00
Modify  | 0.72005    | 0.72005    | 0.72005    |   0.0 |  0.11
Other   |            | 0.09757    |            |       |  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:       539068 ave      539068 max      539068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539068
Ave neighs/atom = 134.767
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 = 332.588397417147, Press = -1.09346854762285
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  -13082.086     -13082.086     -13257.503     -13257.503      339.35613      339.35613      67627.927      67627.927     -899.49534     -899.49534    
     40000  -13088.712     -13088.712     -13258.536     -13258.536      328.53678      328.53678      67508.63       67508.63       317.02569      317.02569    
Loop time of 684.368 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 190.102 hours/ns, 1.461 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    | 683.39     | 683.39     | 683.39     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15243    | 0.15243    | 0.15243    |   0.0 |  0.02
Output  | 0.00018678 | 0.00018678 | 0.00018678 |   0.0 |  0.00
Modify  | 0.72634    | 0.72634    | 0.72634    |   0.0 |  0.11
Other   |            | 0.09843    |            |       |  0.01

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

Total # of neighbors = 538626
Ave neighs/atom = 134.6565
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 = 332.66337485929, Press = 0.48899108815598
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  -13088.712     -13088.712     -13258.536     -13258.536      328.53678      328.53678      67508.63       67508.63       317.02569      317.02569    
     41000  -13084.344     -13084.344     -13257.058     -13257.058      334.12597      334.12597      67530.578      67530.578      164.83893      164.83893    
Loop time of 681.266 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.241 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.29     | 680.29     | 680.29     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15275    | 0.15275    | 0.15275    |   0.0 |  0.02
Output  | 0.00026945 | 0.00026945 | 0.00026945 |   0.0 |  0.00
Modify  | 0.72516    | 0.72516    | 0.72516    |   0.0 |  0.11
Other   |            | 0.09844    |            |       |  0.01

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

Total # of neighbors = 538932
Ave neighs/atom = 134.733
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 = 332.709271114347, Press = -0.812997526792986
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  -13084.344     -13084.344     -13257.058     -13257.058      334.12597      334.12597      67530.578      67530.578      164.83893      164.83893    
     42000  -13086.426     -13086.426     -13259.089     -13259.089      334.0292       334.0292       67566.169      67566.169     -432.20712     -432.20712    
Loop time of 681.098 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.194 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.13     | 680.13     | 680.13     |   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.00023056 | 0.00023056 | 0.00023056 |   0.0 |  0.00
Modify  | 0.72161    | 0.72161    | 0.72161    |   0.0 |  0.11
Other   |            | 0.09796    |            |       |  0.01

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

Total # of neighbors = 538992
Ave neighs/atom = 134.748
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.677248933643, Press = 0.104206558962884
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  -13086.426     -13086.426     -13259.089     -13259.089      334.0292       334.0292       67566.169      67566.169     -432.20712     -432.20712    
     43000  -13087.718     -13087.718     -13263.162     -13263.162      339.40756      339.40756      67472.101      67472.101      494.5474       494.5474     
Loop time of 683.982 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 189.995 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    | 683.01     | 683.01     | 683.01     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1515     | 0.1515     | 0.1515     |   0.0 |  0.02
Output  | 0.00023968 | 0.00023968 | 0.00023968 |   0.0 |  0.00
Modify  | 0.72582    | 0.72582    | 0.72582    |   0.0 |  0.11
Other   |            | 0.09864    |            |       |  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:       538724 ave      538724 max      538724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538724
Ave neighs/atom = 134.681
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 = 332.658497021735, Press = -0.65876378634596
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  -13087.718     -13087.718     -13263.162     -13263.162      339.40756      339.40756      67472.101      67472.101      494.5474       494.5474     
     44000  -13091.619     -13091.619     -13261.436     -13261.436      328.52132      328.52132      67668.475      67668.475     -1779.9384     -1779.9384    
Loop time of 688.012 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 191.114 hours/ns, 1.453 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    | 687.03     | 687.03     | 687.03     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15226    | 0.15226    | 0.15226    |   0.0 |  0.02
Output  | 0.00023522 | 0.00023522 | 0.00023522 |   0.0 |  0.00
Modify  | 0.7292     | 0.7292     | 0.7292     |   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:           6052 ave        6052 max        6052 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:       539054 ave      539054 max      539054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539054
Ave neighs/atom = 134.7635
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 = 332.624171809195, Press = -0.0275235000313707
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  -13091.619     -13091.619     -13261.436     -13261.436      328.52132      328.52132      67668.475      67668.475     -1779.9384     -1779.9384    
     45000  -13088.196     -13088.196     -13260.333     -13260.333      333.01222      333.01222      67413.977      67413.977      1180.7377      1180.7377    
Loop time of 684.975 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 190.271 hours/ns, 1.460 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    | 683.99     | 683.99     | 683.99     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15276    | 0.15276    | 0.15276    |   0.0 |  0.02
Output  | 0.00018863 | 0.00018863 | 0.00018863 |   0.0 |  0.00
Modify  | 0.73044    | 0.73044    | 0.73044    |   0.0 |  0.11
Other   |            | 0.09878    |            |       |  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:       538686 ave      538686 max      538686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538686
Ave neighs/atom = 134.6715
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 = 332.625890325923, Press = 0.102276526190578
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13088.196     -13088.196     -13260.333     -13260.333      333.01222      333.01222      67413.977      67413.977      1180.7377      1180.7377    
     46000  -13079.639     -13079.639     -13252.898     -13252.898      335.18225      335.18225      67651.514      67651.514     -858.81118     -858.81118    
Loop time of 685.614 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 190.448 hours/ns, 1.459 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    | 684.63     | 684.63     | 684.63     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15424    | 0.15424    | 0.15424    |   0.0 |  0.02
Output  | 0.00018696 | 0.00018696 | 0.00018696 |   0.0 |  0.00
Modify  | 0.72683    | 0.72683    | 0.72683    |   0.0 |  0.11
Other   |            | 0.09891    |            |       |  0.01

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

Total # of neighbors = 538984
Ave neighs/atom = 134.746
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 = 332.65027713751, Press = -0.392532748964823
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  -13079.639     -13079.639     -13252.898     -13252.898      335.18225      335.18225      67651.514      67651.514     -858.81118     -858.81118    
     47000  -13087.228     -13087.228     -13260.844     -13260.844      335.8712       335.8712       67493.13       67493.13       312.24216      312.24216    
Loop time of 680.242 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.956 hours/ns, 1.470 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 679.27     | 679.27     | 679.27     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15184    | 0.15184    | 0.15184    |   0.0 |  0.02
Output  | 0.00018941 | 0.00018941 | 0.00018941 |   0.0 |  0.00
Modify  | 0.72294    | 0.72294    | 0.72294    |   0.0 |  0.11
Other   |            | 0.09767    |            |       |  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:       538590 ave      538590 max      538590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538590
Ave neighs/atom = 134.6475
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 = 332.68971711019, Press = 0.285475881493945
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  -13087.228     -13087.228     -13260.844     -13260.844      335.8712       335.8712       67493.13       67493.13       312.24216      312.24216    
     48000  -13088.484     -13088.484     -13259.69      -13259.69       331.21134      331.21134      67556.303      67556.303     -269.55109     -269.55109    
Loop time of 685.77 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 684.79     | 684.79     | 684.79     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15298    | 0.15298    | 0.15298    |   0.0 |  0.02
Output  | 0.00018883 | 0.00018883 | 0.00018883 |   0.0 |  0.00
Modify  | 0.72838    | 0.72838    | 0.72838    |   0.0 |  0.11
Other   |            | 0.09863    |            |       |  0.01

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

Total # of neighbors = 539008
Ave neighs/atom = 134.752
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 = 332.708566810452, Press = -0.719255598149035
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  -13088.484     -13088.484     -13259.69      -13259.69       331.21134      331.21134      67556.303      67556.303     -269.55109     -269.55109    
     49000  -13082.859     -13082.859     -13256.331     -13256.331      335.59357      335.59357      67548.093      67548.093      41.378707      41.378707    
Loop time of 681.709 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.364 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.73     | 680.73     | 680.73     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15183    | 0.15183    | 0.15183    |   0.0 |  0.02
Output  | 0.00024485 | 0.00024485 | 0.00024485 |   0.0 |  0.00
Modify  | 0.72509    | 0.72509    | 0.72509    |   0.0 |  0.11
Other   |            | 0.09844    |            |       |  0.01

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

Total # of neighbors = 538686
Ave neighs/atom = 134.6715
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 = 332.723647136071, Press = 0.504607109262533
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  -13082.859     -13082.859     -13256.331     -13256.331      335.59357      335.59357      67548.093      67548.093      41.378707      41.378707    
     50000  -13083.882     -13083.882     -13259.99      -13259.99       340.69441      340.69441      67511.347      67511.347      245.90559      245.90559    
Loop time of 674.982 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.495 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.02     | 674.02     | 674.02     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15035    | 0.15035    | 0.15035    |   0.0 |  0.02
Output  | 0.00018513 | 0.00018513 | 0.00018513 |   0.0 |  0.00
Modify  | 0.71145    | 0.71145    | 0.71145    |   0.0 |  0.11
Other   |            | 0.09753    |            |       |  0.01

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

Total # of neighbors = 538786
Ave neighs/atom = 134.6965
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 = 332.738083998423, Press = -1.18568126624446
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  -13083.882     -13083.882     -13259.99      -13259.99       340.69441      340.69441      67511.347      67511.347      245.90559      245.90559    
     51000  -13092.808     -13092.808     -13263.028     -13263.028      329.30183      329.30183      67604.688      67604.688     -1085.7802     -1085.7802    
Loop time of 674.803 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.445 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.84     | 673.84     | 673.84     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14976    | 0.14976    | 0.14976    |   0.0 |  0.02
Output  | 0.00023265 | 0.00023265 | 0.00023265 |   0.0 |  0.00
Modify  | 0.71339    | 0.71339    | 0.71339    |   0.0 |  0.11
Other   |            | 0.09803    |            |       |  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:       539026 ave      539026 max      539026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539026
Ave neighs/atom = 134.7565
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 = 332.731362240303, Press = 0.810983787508151
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  -13092.808     -13092.808     -13263.028     -13263.028      329.30183      329.30183      67604.688      67604.688     -1085.7802     -1085.7802    
     52000  -13086.42      -13086.42      -13257.906     -13257.906      331.75081      331.75081      67491.906      67491.906      545.10223      545.10223    
Loop time of 674.946 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.485 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.99     | 673.99     | 673.99     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15091    | 0.15091    | 0.15091    |   0.0 |  0.02
Output  | 0.00018991 | 0.00018991 | 0.00018991 |   0.0 |  0.00
Modify  | 0.71155    | 0.71155    | 0.71155    |   0.0 |  0.11
Other   |            | 0.09723    |            |       |  0.01

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

Total # of neighbors = 538670
Ave neighs/atom = 134.6675
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 = 332.732842086815, Press = -0.236792146038368
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   
     52000  -13086.42      -13086.42      -13257.906     -13257.906      331.75081      331.75081      67491.906      67491.906      545.10223      545.10223    
     53000  -13081.17      -13081.17      -13255.241     -13255.241      336.75177      336.75177      67588.615      67588.615     -306.60748     -306.60748    
Loop time of 675.215 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.560 hours/ns, 1.481 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 674.26     | 674.26     | 674.26     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14986    | 0.14986    | 0.14986    |   0.0 |  0.02
Output  | 0.00024276 | 0.00024276 | 0.00024276 |   0.0 |  0.00
Modify  | 0.71283    | 0.71283    | 0.71283    |   0.0 |  0.11
Other   |            | 0.09751    |            |       |  0.01

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

Total # of neighbors = 538908
Ave neighs/atom = 134.727
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 = 332.754769751897, Press = -0.0607824644984567
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   
     53000  -13081.17      -13081.17      -13255.241     -13255.241      336.75177      336.75177      67588.615      67588.615     -306.60748     -306.60748    
     54000  -13087.954     -13087.954     -13259.798     -13259.798      332.44404      332.44404      67478.813      67478.813      573.15704      573.15704    
Loop time of 673.603 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 187.112 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.64     | 672.64     | 672.64     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15132    | 0.15132    | 0.15132    |   0.0 |  0.02
Output  | 0.00018542 | 0.00018542 | 0.00018542 |   0.0 |  0.00
Modify  | 0.71172    | 0.71172    | 0.71172    |   0.0 |  0.11
Other   |            | 0.09775    |            |       |  0.01

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

Total # of neighbors = 538732
Ave neighs/atom = 134.683
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 = 332.798457212544, Press = -0.375998993601361
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   
     54000  -13087.954     -13087.954     -13259.798     -13259.798      332.44404      332.44404      67478.813      67478.813      573.15704      573.15704    
     55000  -13081.576     -13081.576     -13256.676     -13256.676      338.74309      338.74309      67662.987      67662.987     -1228.0174     -1228.0174    
Loop time of 679.879 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.855 hours/ns, 1.471 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 678.91     | 678.91     | 678.91     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15092    | 0.15092    | 0.15092    |   0.0 |  0.02
Output  | 0.00019506 | 0.00019506 | 0.00019506 |   0.0 |  0.00
Modify  | 0.71963    | 0.71963    | 0.71963    |   0.0 |  0.11
Other   |            | 0.09769    |            |       |  0.01

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

Total # of neighbors = 539050
Ave neighs/atom = 134.7625
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 = 332.84041850921, Press = -0.359125496905993
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   
     55000  -13081.576     -13081.576     -13256.676     -13256.676      338.74309      338.74309      67662.987      67662.987     -1228.0174     -1228.0174    
     56000  -13087.443     -13087.443     -13258.592     -13258.592      331.09961      331.09961      67422.89       67422.89       1239.1822      1239.1822    
Loop time of 677.388 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.128 ns/day, 188.163 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.42     | 676.42     | 676.42     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15144    | 0.15144    | 0.15144    |   0.0 |  0.02
Output  | 0.00018776 | 0.00018776 | 0.00018776 |   0.0 |  0.00
Modify  | 0.71821    | 0.71821    | 0.71821    |   0.0 |  0.11
Other   |            | 0.09842    |            |       |  0.01

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

Total # of neighbors = 538438
Ave neighs/atom = 134.6095
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 = 332.819218355935, Press = 0.0106930204540478
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   
     56000  -13087.443     -13087.443     -13258.592     -13258.592      331.09961      331.09961      67422.89       67422.89       1239.1822      1239.1822    
     57000  -13086.359     -13086.359     -13260.48      -13260.48       336.848        336.848        67642.265      67642.265     -1245.1486     -1245.1486    
Loop time of 680.775 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.104 hours/ns, 1.469 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 679.8      | 679.8      | 679.8      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14986    | 0.14986    | 0.14986    |   0.0 |  0.02
Output  | 0.00026347 | 0.00026347 | 0.00026347 |   0.0 |  0.00
Modify  | 0.72516    | 0.72516    | 0.72516    |   0.0 |  0.11
Other   |            | 0.09917    |            |       |  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:       539198 ave      539198 max      539198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 539198
Ave neighs/atom = 134.7995
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 = 332.821716842876, Press = -0.611023325102051
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   
     57000  -13086.359     -13086.359     -13260.48      -13260.48       336.848        336.848        67642.265      67642.265     -1245.1486     -1245.1486    
     58000  -13088.257     -13088.257     -13260.259     -13260.259      332.74778      332.74778      67455.178      67455.178      837.05193      837.05193    
Loop time of 688.804 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.125 ns/day, 191.335 hours/ns, 1.452 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 687.82     | 687.82     | 687.82     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15146    | 0.15146    | 0.15146    |   0.0 |  0.02
Output  | 0.00018442 | 0.00018442 | 0.00018442 |   0.0 |  0.00
Modify  | 0.73253    | 0.73253    | 0.73253    |   0.0 |  0.11
Other   |            | 0.09897    |            |       |  0.01

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

Total # of neighbors = 538600
Ave neighs/atom = 134.65
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 = 332.838646505703, Press = 0.266479722106435
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   
     58000  -13088.257     -13088.257     -13260.259     -13260.259      332.74778      332.74778      67455.178      67455.178      837.05193      837.05193    
     59000  -13081.458     -13081.458     -13257.451     -13257.451      340.46951      340.46951      67619.078      67619.078     -706.8845      -706.8845     
Loop time of 691.252 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.125 ns/day, 192.015 hours/ns, 1.447 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 690.26     | 690.26     | 690.26     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15288    | 0.15288    | 0.15288    |   0.0 |  0.02
Output  | 0.0001883  | 0.0001883  | 0.0001883  |   0.0 |  0.00
Modify  | 0.73581    | 0.73581    | 0.73581    |   0.0 |  0.11
Other   |            | 0.09952    |            |       |  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:       538992 ave      538992 max      538992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538992
Ave neighs/atom = 134.748
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.872991007313, Press = -0.570592623517754
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   
     59000  -13081.458     -13081.458     -13257.451     -13257.451      340.46951      340.46951      67619.078      67619.078     -706.8845      -706.8845     
     60000  -13088.391     -13088.391     -13261.344     -13261.344      334.5884       334.5884       67521.264      67521.264      20.618153      20.618153    
Loop time of 688.094 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 191.137 hours/ns, 1.453 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 687.1      | 687.1      | 687.1      |   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.00023872 | 0.00023872 | 0.00023872 |   0.0 |  0.00
Modify  | 0.73675    | 0.73675    | 0.73675    |   0.0 |  0.11
Other   |            | 0.09954    |            |       |  0.01

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

Total # of neighbors = 538720
Ave neighs/atom = 134.68
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 = 332.901269472633, Press = 0.441309059943242
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   
     60000  -13088.391     -13088.391     -13261.344     -13261.344      334.5884       334.5884       67521.264      67521.264      20.618153      20.618153    
     61000  -13081.413     -13081.413     -13256.526     -13256.526      338.76763      338.76763      67511.278      67511.278      521.67852      521.67852    
Loop time of 698.764 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.124 ns/day, 194.101 hours/ns, 1.431 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 697.76     | 697.76     | 697.76     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15516    | 0.15516    | 0.15516    |   0.0 |  0.02
Output  | 0.00023408 | 0.00023408 | 0.00023408 |   0.0 |  0.00
Modify  | 0.74833    | 0.74833    | 0.74833    |   0.0 |  0.11
Other   |            | 0.09993    |            |       |  0.01

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

Total # of neighbors = 538906
Ave neighs/atom = 134.7265
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 = 332.936123925718, Press = -0.911235521055911
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   
     61000  -13081.413     -13081.413     -13256.526     -13256.526      338.76763      338.76763      67511.278      67511.278      521.67852      521.67852    
     62000  -13091.257     -13091.257     -13262.083     -13262.083      330.47573      330.47573      67630.211      67630.211     -1239.0765     -1239.0765    
Loop time of 691.13 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.125 ns/day, 191.981 hours/ns, 1.447 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 690.14     | 690.14     | 690.14     |   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.00018567 | 0.00018567 | 0.00018567 |   0.0 |  0.00
Modify  | 0.73834    | 0.73834    | 0.73834    |   0.0 |  0.11
Other   |            | 0.09945    |            |       |  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:       538780 ave      538780 max      538780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538780
Ave neighs/atom = 134.695
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 = 332.955824753214, Press = 0.721098102146107
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   
     62000  -13091.257     -13091.257     -13262.083     -13262.083      330.47573      330.47573      67630.211      67630.211     -1239.0765     -1239.0765    
     63000  -13086.389     -13086.389     -13257.235     -13257.235      330.51356      330.51356      67466.123      67466.123      909.86911      909.86911    
Loop time of 684.545 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 190.152 hours/ns, 1.461 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 683.56     | 683.56     | 683.56     |   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.00018888 | 0.00018888 | 0.00018888 |   0.0 |  0.00
Modify  | 0.73426    | 0.73426    | 0.73426    |   0.0 |  0.11
Other   |            | 0.09953    |            |       |  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:       538678 ave      538678 max      538678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538678
Ave neighs/atom = 134.6695
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 = 332.957477563904, Press = -0.20218723073991
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   
     63000  -13086.389     -13086.389     -13257.235     -13257.235      330.51356      330.51356      67466.123      67466.123      909.86911      909.86911    
     64000  -13085.229     -13085.229     -13255.991     -13255.991      330.35105      330.35105      67602.545      67602.545     -552.85354     -552.85354    
Loop time of 679.713 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 188.809 hours/ns, 1.471 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 678.74     | 678.74     | 678.74     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15144    | 0.15144    | 0.15144    |   0.0 |  0.02
Output  | 0.00018694 | 0.00018694 | 0.00018694 |   0.0 |  0.00
Modify  | 0.72124    | 0.72124    | 0.72124    |   0.0 |  0.11
Other   |            | 0.09794    |            |       |  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:       538952 ave      538952 max      538952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538952
Ave neighs/atom = 134.738
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
67531.8693792419

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0