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

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

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

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_150993986463_001#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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8499.0849     -8499.0849     -8580          -8580           313.15         313.15         23483.517      23483.517      3680.3383      3680.3383    
      1000  -8414.062      -8414.062      -8492.0255     -8492.0255      301.72682      301.72682      23708.302      23708.302      2542.4029      2542.4029    
Loop time of 21.8599 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.952 ns/day, 6.072 hours/ns, 45.746 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.778     | 21.778     | 21.778     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015417   | 0.015417   | 0.015417   |   0.0 |  0.07
Output  | 0.00013538 | 0.00013538 | 0.00013538 |   0.0 |  0.00
Modify  | 0.060581   | 0.060581   | 0.060581   |   0.0 |  0.28
Other   |            | 0.005564   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8414.062      -8414.062      -8492.0255     -8492.0255      301.72682      301.72682      23708.302      23708.302      2542.4029      2542.4029    
      2000  -8414.7194     -8414.7194     -8495.0452     -8495.0452      310.86924      310.86924      23746.308      23746.308     -482.38476     -482.38476    
Loop time of 24.5745 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.516 ns/day, 6.826 hours/ns, 40.693 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.494     | 24.494     | 24.494     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015105   | 0.015105   | 0.015105   |   0.0 |  0.06
Output  | 4.5295e-05 | 4.5295e-05 | 4.5295e-05 |   0.0 |  0.00
Modify  | 0.059823   | 0.059823   | 0.059823   |   0.0 |  0.24
Other   |            | 0.005466   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128076 ave      128076 max      128076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128076
Ave neighs/atom = 64.038
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8414.7194     -8414.7194     -8495.0452     -8495.0452      310.86924      310.86924      23746.308      23746.308     -482.38476     -482.38476    
      3000  -8416.0069     -8416.0069     -8490.7018     -8490.7018      289.07702      289.07702      23753.35       23753.35      -578.65126     -578.65126    
Loop time of 25.1524 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.435 ns/day, 6.987 hours/ns, 39.758 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.071     | 25.071     | 25.071     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015244   | 0.015244   | 0.015244   |   0.0 |  0.06
Output  | 3.9845e-05 | 3.9845e-05 | 3.9845e-05 |   0.0 |  0.00
Modify  | 0.060149   | 0.060149   | 0.060149   |   0.0 |  0.24
Other   |            | 0.005483   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128102 ave      128102 max      128102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128102
Ave neighs/atom = 64.051
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8416.0069     -8416.0069     -8490.7018     -8490.7018      289.07702      289.07702      23753.35       23753.35      -578.65126     -578.65126    
      4000  -8413.6593     -8413.6593     -8496.6671     -8496.6671      321.249        321.249        23743.726      23743.726     -533.69721     -533.69721    
Loop time of 25.0486 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.449 ns/day, 6.958 hours/ns, 39.922 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.968     | 24.968     | 24.968     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015133   | 0.015133   | 0.015133   |   0.0 |  0.06
Output  | 3.4134e-05 | 3.4134e-05 | 3.4134e-05 |   0.0 |  0.00
Modify  | 0.059875   | 0.059875   | 0.059875   |   0.0 |  0.24
Other   |            | 0.005476   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128048 ave      128048 max      128048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128048
Ave neighs/atom = 64.024
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8413.6593     -8413.6593     -8496.6671     -8496.6671      321.249        321.249        23743.726      23743.726     -533.69721     -533.69721    
      5000  -8415.9571     -8415.9571     -8498.1066     -8498.1066      317.92724      317.92724      23721.375      23721.375      911.04446      911.04446    
Loop time of 24.9819 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.459 ns/day, 6.939 hours/ns, 40.029 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.901     | 24.901     | 24.901     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015143   | 0.015143   | 0.015143   |   0.0 |  0.06
Output  | 2.8894e-05 | 2.8894e-05 | 2.8894e-05 |   0.0 |  0.00
Modify  | 0.059983   | 0.059983   | 0.059983   |   0.0 |  0.24
Other   |            | 0.005451   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128024 ave      128024 max      128024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128024
Ave neighs/atom = 64.012
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.069165072102, Press = 1174.45647265193
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8415.9571     -8415.9571     -8498.1066     -8498.1066      317.92724      317.92724      23721.375      23721.375      911.04446      911.04446    
      6000  -8413.7763     -8413.7763     -8498.326      -8498.326       327.21613      327.21613      23685.076      23685.076      3615.8594      3615.8594    
Loop time of 24.93 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.466 ns/day, 6.925 hours/ns, 40.112 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.847     | 24.847     | 24.847     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015204   | 0.015204   | 0.015204   |   0.0 |  0.06
Output  | 3.197e-05  | 3.197e-05  | 3.197e-05  |   0.0 |  0.00
Modify  | 0.062082   | 0.062082   | 0.062082   |   0.0 |  0.25
Other   |            | 0.005437   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128046 ave      128046 max      128046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128046
Ave neighs/atom = 64.023
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 = 311.959595069822, Press = 91.8072388357307
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8413.7763     -8413.7763     -8498.326      -8498.326       327.21613      327.21613      23685.076      23685.076      3615.8594      3615.8594    
      7000  -8418.4177     -8418.4177     -8499.41       -8499.41        313.44883      313.44883      23710.651      23710.651      1369.6543      1369.6543    
Loop time of 24.9738 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.460 ns/day, 6.937 hours/ns, 40.042 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.891     | 24.891     | 24.891     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01522    | 0.01522    | 0.01522    |   0.0 |  0.06
Output  | 2.2362e-05 | 2.2362e-05 | 2.2362e-05 |   0.0 |  0.00
Modify  | 0.062047   | 0.062047   | 0.062047   |   0.0 |  0.25
Other   |            | 0.0054     |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128086 ave      128086 max      128086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128086
Ave neighs/atom = 64.043
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 = 311.671257122998, Press = 15.1596222859904
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8418.4177     -8418.4177     -8499.41       -8499.41        313.44883      313.44883      23710.651      23710.651      1369.6543      1369.6543    
      8000  -8414.3589     -8414.3589     -8495.3885     -8495.3885      313.59303      313.59303      23736.073      23736.073      185.3391       185.3391     
Loop time of 24.8949 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.471 ns/day, 6.915 hours/ns, 40.169 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.812     | 24.812     | 24.812     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015291   | 0.015291   | 0.015291   |   0.0 |  0.06
Output  | 2.9535e-05 | 2.9535e-05 | 2.9535e-05 |   0.0 |  0.00
Modify  | 0.062242   | 0.062242   | 0.062242   |   0.0 |  0.25
Other   |            | 0.005395   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128034 ave      128034 max      128034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128034
Ave neighs/atom = 64.017
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 = 311.319776023706, Press = 9.41198435897028
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8414.3589     -8414.3589     -8495.3885     -8495.3885      313.59303      313.59303      23736.073      23736.073      185.3391       185.3391     
      9000  -8416.352      -8416.352      -8494.43       -8494.43        302.16987      302.16987      23743.61       23743.61      -280.05821     -280.05821    
Loop time of 25.0232 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.453 ns/day, 6.951 hours/ns, 39.963 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.94      | 24.94      | 24.94      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015246   | 0.015246   | 0.015246   |   0.0 |  0.06
Output  | 2.2802e-05 | 2.2802e-05 | 2.2802e-05 |   0.0 |  0.00
Modify  | 0.062297   | 0.062297   | 0.062297   |   0.0 |  0.25
Other   |            | 0.005417   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128036 ave      128036 max      128036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128036
Ave neighs/atom = 64.018
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 = 311.618545780351, Press = 8.26579509205349
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8416.352      -8416.352      -8494.43       -8494.43        302.16987      302.16987      23743.61       23743.61      -280.05821     -280.05821    
     10000  -8412.7379     -8412.7379     -8494.8522     -8494.8522      317.7907       317.7907       23757.258      23757.258     -1184.3877     -1184.3877    
Loop time of 25.0792 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.445 ns/day, 6.966 hours/ns, 39.874 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.996     | 24.996     | 24.996     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015222   | 0.015222   | 0.015222   |   0.0 |  0.06
Output  | 2.8734e-05 | 2.8734e-05 | 2.8734e-05 |   0.0 |  0.00
Modify  | 0.062142   | 0.062142   | 0.062142   |   0.0 |  0.25
Other   |            | 0.005407   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128058 ave      128058 max      128058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128058
Ave neighs/atom = 64.029
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 = 311.362882520185, Press = 7.88017509054711
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8412.7379     -8412.7379     -8494.8522     -8494.8522      317.7907       317.7907       23757.258      23757.258     -1184.3877     -1184.3877    
     11000  -8414.8368     -8414.8368     -8496.1028     -8496.1028      314.50802      314.50802      23766.434      23766.434     -1970.8886     -1970.8886    
Loop time of 25.0259 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.452 ns/day, 6.952 hours/ns, 39.959 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.943     | 24.943     | 24.943     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015211   | 0.015211   | 0.015211   |   0.0 |  0.06
Output  | 2.15e-05   | 2.15e-05   | 2.15e-05   |   0.0 |  0.00
Modify  | 0.062176   | 0.062176   | 0.062176   |   0.0 |  0.25
Other   |            | 0.005395   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128034 ave      128034 max      128034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128034
Ave neighs/atom = 64.017
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 = 311.742956277328, Press = 7.54623910517724
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8414.8368     -8414.8368     -8496.1028     -8496.1028      314.50802      314.50802      23766.434      23766.434     -1970.8886     -1970.8886    
     12000  -8414.4914     -8414.4914     -8496.1106     -8496.1106      315.87491      315.87491      23766.456      23766.456     -1917.1046     -1917.1046    
Loop time of 25.0874 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.444 ns/day, 6.969 hours/ns, 39.861 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.004     | 25.004     | 25.004     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015309   | 0.015309   | 0.015309   |   0.0 |  0.06
Output  | 2.2032e-05 | 2.2032e-05 | 2.2032e-05 |   0.0 |  0.00
Modify  | 0.062269   | 0.062269   | 0.062269   |   0.0 |  0.25
Other   |            | 0.005407   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128014 ave      128014 max      128014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128014
Ave neighs/atom = 64.007
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.412717502566, Press = 12.4544668882844
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8414.4914     -8414.4914     -8496.1106     -8496.1106      315.87491      315.87491      23766.456      23766.456     -1917.1046     -1917.1046    
     13000  -8412.4545     -8412.4545     -8494.2157     -8494.2157      316.42424      316.42424      23752.086      23752.086     -695.94211     -695.94211    
Loop time of 25.1152 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.440 ns/day, 6.976 hours/ns, 39.816 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.032     | 25.032     | 25.032     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015362   | 0.015362   | 0.015362   |   0.0 |  0.06
Output  | 3.0127e-05 | 3.0127e-05 | 3.0127e-05 |   0.0 |  0.00
Modify  | 0.062454   | 0.062454   | 0.062454   |   0.0 |  0.25
Other   |            | 0.005395   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128020 ave      128020 max      128020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128020
Ave neighs/atom = 64.01
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.523930696363, Press = 14.3090457162474
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8412.4545     -8412.4545     -8494.2157     -8494.2157      316.42424      316.42424      23752.086      23752.086     -695.94211     -695.94211    
     14000  -8416.1103     -8416.1103     -8497.9154     -8497.9154      316.59443      316.59443      23717.477      23717.477      1057.8702      1057.8702    
Loop time of 25.1279 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.438 ns/day, 6.980 hours/ns, 39.796 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.045     | 25.045     | 25.045     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015243   | 0.015243   | 0.015243   |   0.0 |  0.06
Output  | 5.3711e-05 | 5.3711e-05 | 5.3711e-05 |   0.0 |  0.00
Modify  | 0.062464   | 0.062464   | 0.062464   |   0.0 |  0.25
Other   |            | 0.005417   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128022 ave      128022 max      128022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128022
Ave neighs/atom = 64.011
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.734715886853, Press = 12.3113701947516
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8416.1103     -8416.1103     -8497.9154     -8497.9154      316.59443      316.59443      23717.477      23717.477      1057.8702      1057.8702    
     15000  -8412.3635     -8412.3635     -8494.0267     -8494.0267      316.045        316.045        23724.946      23724.946      1279.684       1279.684     
Loop time of 25.1434 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.436 ns/day, 6.984 hours/ns, 39.772 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.061     | 25.061     | 25.061     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015245   | 0.015245   | 0.015245   |   0.0 |  0.06
Output  | 3.4195e-05 | 3.4195e-05 | 3.4195e-05 |   0.0 |  0.00
Modify  | 0.062131   | 0.062131   | 0.062131   |   0.0 |  0.25
Other   |            | 0.005394   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128030 ave      128030 max      128030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128030
Ave neighs/atom = 64.015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.683347546046, Press = 6.31465811150679
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8412.3635     -8412.3635     -8494.0267     -8494.0267      316.045        316.045        23724.946      23724.946      1279.684       1279.684     
     16000  -8417.5689     -8417.5689     -8496.2893     -8496.2893      304.65612      304.65612      23726.209      23726.209      800.78148      800.78148    
Loop time of 25.1325 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.438 ns/day, 6.981 hours/ns, 39.789 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.049     | 25.049     | 25.049     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015204   | 0.015204   | 0.015204   |   0.0 |  0.06
Output  | 2.1641e-05 | 2.1641e-05 | 2.1641e-05 |   0.0 |  0.00
Modify  | 0.062431   | 0.062431   | 0.062431   |   0.0 |  0.25
Other   |            | 0.005426   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128048 ave      128048 max      128048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128048
Ave neighs/atom = 64.024
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.795033353463, Press = 3.55792613844976
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8417.5689     -8417.5689     -8496.2893     -8496.2893      304.65612      304.65612      23726.209      23726.209      800.78148      800.78148    
     17000  -8409.6336     -8409.6336     -8494.9123     -8494.9123      330.03765      330.03765      23741.734      23741.734      129.59762      129.59762    
Loop time of 25.1012 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.442 ns/day, 6.973 hours/ns, 39.839 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.018     | 25.018     | 25.018     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015258   | 0.015258   | 0.015258   |   0.0 |  0.06
Output  | 3.196e-05  | 3.196e-05  | 3.196e-05  |   0.0 |  0.00
Modify  | 0.062517   | 0.062517   | 0.062517   |   0.0 |  0.25
Other   |            | 0.005429   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128052 ave      128052 max      128052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128052
Ave neighs/atom = 64.026
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.919771600791, Press = 2.70708742243572
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8409.6336     -8409.6336     -8494.9123     -8494.9123      330.03765      330.03765      23741.734      23741.734      129.59762      129.59762    
     18000  -8415.4947     -8415.4947     -8496.8207     -8496.8207      314.74037      314.74037      23734.591      23734.591      40.317552      40.317552    
Loop time of 25.2051 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.428 ns/day, 7.001 hours/ns, 39.674 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.122     | 25.122     | 25.122     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015246   | 0.015246   | 0.015246   |   0.0 |  0.06
Output  | 2.9886e-05 | 2.9886e-05 | 2.9886e-05 |   0.0 |  0.00
Modify  | 0.062543   | 0.062543   | 0.062543   |   0.0 |  0.25
Other   |            | 0.005418   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128032 ave      128032 max      128032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128032
Ave neighs/atom = 64.016
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.075329803485, Press = 1.16072379981415
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8415.4947     -8415.4947     -8496.8207     -8496.8207      314.74037      314.74037      23734.591      23734.591      40.317552      40.317552    
     19000  -8413.6359     -8413.6359     -8493.6294     -8493.6294      309.58298      309.58298      23758.518      23758.518     -1185.3901     -1185.3901    
Loop time of 25.3351 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.410 ns/day, 7.038 hours/ns, 39.471 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.252     | 25.252     | 25.252     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015274   | 0.015274   | 0.015274   |   0.0 |  0.06
Output  | 2.1811e-05 | 2.1811e-05 | 2.1811e-05 |   0.0 |  0.00
Modify  | 0.062466   | 0.062466   | 0.062466   |   0.0 |  0.25
Other   |            | 0.0054     |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128058 ave      128058 max      128058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128058
Ave neighs/atom = 64.029
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.260369181032, Press = -3.35552435137282
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8413.6359     -8413.6359     -8493.6294     -8493.6294      309.58298      309.58298      23758.518      23758.518     -1185.3901     -1185.3901    
     20000  -8413.4579     -8413.4579     -8495.293      -8495.293       316.71036      316.71036      23779.025      23779.025     -2878.2664     -2878.2664    
Loop time of 25.369 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.406 ns/day, 7.047 hours/ns, 39.418 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.285     | 25.285     | 25.285     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015409   | 0.015409   | 0.015409   |   0.0 |  0.06
Output  | 2.8153e-05 | 2.8153e-05 | 2.8153e-05 |   0.0 |  0.00
Modify  | 0.06271    | 0.06271    | 0.06271    |   0.0 |  0.25
Other   |            | 0.005402   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128042 ave      128042 max      128042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128042
Ave neighs/atom = 64.021
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.213754960111, Press = -0.422929055173351
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8413.4579     -8413.4579     -8495.293      -8495.293       316.71036      316.71036      23779.025      23779.025     -2878.2664     -2878.2664    
     21000  -8414.394      -8414.394      -8496.0341     -8496.0341      315.95564      315.95564      23772.484      23772.484     -2513.4077     -2513.4077    
Loop time of 25.3877 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.403 ns/day, 7.052 hours/ns, 39.389 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.304     | 25.304     | 25.304     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015393   | 0.015393   | 0.015393   |   0.0 |  0.06
Output  | 2.1781e-05 | 2.1781e-05 | 2.1781e-05 |   0.0 |  0.00
Modify  | 0.062862   | 0.062862   | 0.062862   |   0.0 |  0.25
Other   |            | 0.005446   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128062 ave      128062 max      128062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128062
Ave neighs/atom = 64.031
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.109243397716, Press = 3.04625609191943
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8414.394      -8414.394      -8496.0341     -8496.0341      315.95564      315.95564      23772.484      23772.484     -2513.4077     -2513.4077    
     22000  -8411.1629     -8411.1629     -8494.6178     -8494.6178      322.97912      322.97912      23758.496      23758.496     -1140.2038     -1140.2038    
Loop time of 25.2913 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.416 ns/day, 7.025 hours/ns, 39.539 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.208     | 25.208     | 25.208     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015339   | 0.015339   | 0.015339   |   0.0 |  0.06
Output  | 3.3874e-05 | 3.3874e-05 | 3.3874e-05 |   0.0 |  0.00
Modify  | 0.062706   | 0.062706   | 0.062706   |   0.0 |  0.25
Other   |            | 0.005454   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128038 ave      128038 max      128038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128038
Ave neighs/atom = 64.019
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.063780839924, Press = 4.21733247121286
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8411.1629     -8411.1629     -8494.6178     -8494.6178      322.97912      322.97912      23758.496      23758.496     -1140.2038     -1140.2038    
     23000  -8416.5374     -8416.5374     -8495.7087     -8495.7087      306.40119      306.40119      23734.341      23734.341      232.6042       232.6042     
Loop time of 25.2805 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.418 ns/day, 7.022 hours/ns, 39.556 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.197     | 25.197     | 25.197     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015299   | 0.015299   | 0.015299   |   0.0 |  0.06
Output  | 2.1831e-05 | 2.1831e-05 | 2.1831e-05 |   0.0 |  0.00
Modify  | 0.062661   | 0.062661   | 0.062661   |   0.0 |  0.25
Other   |            | 0.005428   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 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:       128030 ave      128030 max      128030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128030
Ave neighs/atom = 64.015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.234275238711, Press = 3.60774590182051
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8416.5374     -8416.5374     -8495.7087     -8495.7087      306.40119      306.40119      23734.341      23734.341      232.6042       232.6042     
     24000  -8413.5464     -8413.5464     -8494.5086     -8494.5086      313.33228      313.33228      23732.554      23732.554      780.11547      780.11547    
Loop time of 25.2754 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.418 ns/day, 7.021 hours/ns, 39.564 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.192     | 25.192     | 25.192     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015381   | 0.015381   | 0.015381   |   0.0 |  0.06
Output  | 2.3093e-05 | 2.3093e-05 | 2.3093e-05 |   0.0 |  0.00
Modify  | 0.06275    | 0.06275    | 0.06275    |   0.0 |  0.25
Other   |            | 0.005422   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128074 ave      128074 max      128074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128074
Ave neighs/atom = 64.037
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.263422294115, Press = 3.02325641972342
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8413.5464     -8413.5464     -8494.5086     -8494.5086      313.33228      313.33228      23732.554      23732.554      780.11547      780.11547    
     25000  -8413.4001     -8413.4001     -8495.6883     -8495.6883      318.46374      318.46374      23722.718      23722.718      1207.399       1207.399     
Loop time of 25.3056 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.414 ns/day, 7.029 hours/ns, 39.517 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.222     | 25.222     | 25.222     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015347   | 0.015347   | 0.015347   |   0.0 |  0.06
Output  | 3.0508e-05 | 3.0508e-05 | 3.0508e-05 |   0.0 |  0.00
Modify  | 0.062837   | 0.062837   | 0.062837   |   0.0 |  0.25
Other   |            | 0.005447   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128042 ave      128042 max      128042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128042
Ave neighs/atom = 64.021
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.216942468931, Press = 2.88286891550431
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8413.4001     -8413.4001     -8495.6883     -8495.6883      318.46374      318.46374      23722.718      23722.718      1207.399       1207.399     
     26000  -8416.4206     -8416.4206     -8494.3659     -8494.3659      301.65629      301.65629      23698.022      23698.022      3036.249       3036.249     
Loop time of 25.3117 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.413 ns/day, 7.031 hours/ns, 39.507 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.228     | 25.228     | 25.228     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015283   | 0.015283   | 0.015283   |   0.0 |  0.06
Output  | 2.1981e-05 | 2.1981e-05 | 2.1981e-05 |   0.0 |  0.00
Modify  | 0.062687   | 0.062687   | 0.062687   |   0.0 |  0.25
Other   |            | 0.005453   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128066 ave      128066 max      128066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128066
Ave neighs/atom = 64.033
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.295744006415, Press = 0.722640423711884
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8416.4206     -8416.4206     -8494.3659     -8494.3659      301.65629      301.65629      23698.022      23698.022      3036.249       3036.249     
     27000  -8411.2638     -8411.2638     -8493.7202     -8493.7202      319.11476      319.11476      23722.148      23722.148      1674.7917      1674.7917    
Loop time of 25.0961 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.443 ns/day, 6.971 hours/ns, 39.847 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.013     | 25.013     | 25.013     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015208   | 0.015208   | 0.015208   |   0.0 |  0.06
Output  | 2.9095e-05 | 2.9095e-05 | 2.9095e-05 |   0.0 |  0.00
Modify  | 0.062419   | 0.062419   | 0.062419   |   0.0 |  0.25
Other   |            | 0.005386   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128048 ave      128048 max      128048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128048
Ave neighs/atom = 64.024
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.267837019969, Press = -1.82261628429298
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8411.2638     -8411.2638     -8493.7202     -8493.7202      319.11476      319.11476      23722.148      23722.148      1674.7917      1674.7917    
     28000  -8415.0228     -8415.0228     -8495.1756     -8495.1756      310.19955      310.19955      23748.592      23748.592     -600.05859     -600.05859    
Loop time of 25.0573 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.448 ns/day, 6.960 hours/ns, 39.909 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.974     | 24.974     | 24.974     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015176   | 0.015176   | 0.015176   |   0.0 |  0.06
Output  | 2.1761e-05 | 2.1761e-05 | 2.1761e-05 |   0.0 |  0.00
Modify  | 0.062415   | 0.062415   | 0.062415   |   0.0 |  0.25
Other   |            | 0.005419   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128034 ave      128034 max      128034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128034
Ave neighs/atom = 64.017
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.378084183372, Press = -0.795205103646353
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8415.0228     -8415.0228     -8495.1756     -8495.1756      310.19955      310.19955      23748.592      23748.592     -600.05859     -600.05859    
     29000  -8415.6816     -8415.6816     -8495.4814     -8495.4814      308.83354      308.83354      23759.467      23759.467     -1497.2924     -1497.2924    
Loop time of 25.0955 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.443 ns/day, 6.971 hours/ns, 39.848 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.012     | 25.012     | 25.012     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015366   | 0.015366   | 0.015366   |   0.0 |  0.06
Output  | 2.8143e-05 | 2.8143e-05 | 2.8143e-05 |   0.0 |  0.00
Modify  | 0.062336   | 0.062336   | 0.062336   |   0.0 |  0.25
Other   |            | 0.005428   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128026 ave      128026 max      128026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128026
Ave neighs/atom = 64.013
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.326769951629, Press = 1.64827335475002
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8415.6816     -8415.6816     -8495.4814     -8495.4814      308.83354      308.83354      23759.467      23759.467     -1497.2924     -1497.2924    
     30000  -8415.5383     -8415.5383     -8496.4015     -8496.4015      312.94892      312.94892      23749.047      23749.047     -812.16295     -812.16295    
Loop time of 25.0974 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.443 ns/day, 6.972 hours/ns, 39.845 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.014     | 25.014     | 25.014     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015277   | 0.015277   | 0.015277   |   0.0 |  0.06
Output  | 2.5898e-05 | 2.5898e-05 | 2.5898e-05 |   0.0 |  0.00
Modify  | 0.062335   | 0.062335   | 0.062335   |   0.0 |  0.25
Other   |            | 0.005415   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128038 ave      128038 max      128038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128038
Ave neighs/atom = 64.019
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.263430362704, Press = 2.93341426894394
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8415.5383     -8415.5383     -8496.4015     -8496.4015      312.94892      312.94892      23749.047      23749.047     -812.16295     -812.16295    
     31000  -8415.9645     -8415.9645     -8496.1912     -8496.1912      310.48544      310.48544      23735.601      23735.601      148.32011      148.32011    
Loop time of 25.0954 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.443 ns/day, 6.971 hours/ns, 39.848 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.013     | 25.013     | 25.013     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015229   | 0.015229   | 0.015229   |   0.0 |  0.06
Output  | 2.1861e-05 | 2.1861e-05 | 2.1861e-05 |   0.0 |  0.00
Modify  | 0.062099   | 0.062099   | 0.062099   |   0.0 |  0.25
Other   |            | 0.005403   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128050 ave      128050 max      128050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128050
Ave neighs/atom = 64.025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.148138523092, Press = 3.62801152729899
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8415.9645     -8415.9645     -8496.1912     -8496.1912      310.48544      310.48544      23735.601      23735.601      148.32011      148.32011    
     32000  -8412.7428     -8412.7428     -8494.3745     -8494.3745      315.92291      315.92291      23713.908      23713.908      2129.5383      2129.5383    
Loop time of 25.0285 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.452 ns/day, 6.952 hours/ns, 39.954 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.946     | 24.946     | 24.946     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015142   | 0.015142   | 0.015142   |   0.0 |  0.06
Output  | 2.9245e-05 | 2.9245e-05 | 2.9245e-05 |   0.0 |  0.00
Modify  | 0.062051   | 0.062051   | 0.062051   |   0.0 |  0.25
Other   |            | 0.005418   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128058 ave      128058 max      128058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128058
Ave neighs/atom = 64.029
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.026586309362, Press = 3.36217097588185
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8412.7428     -8412.7428     -8494.3745     -8494.3745      315.92291      315.92291      23713.908      23713.908      2129.5383      2129.5383    
     33000  -8417.5321     -8417.5321     -8497.2693     -8497.2693      308.59113      308.59113      23684.987      23684.987      3534.6346      3534.6346    
Loop time of 25.0311 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.452 ns/day, 6.953 hours/ns, 39.950 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.948     | 24.948     | 24.948     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015233   | 0.015233   | 0.015233   |   0.0 |  0.06
Output  | 2.1991e-05 | 2.1991e-05 | 2.1991e-05 |   0.0 |  0.00
Modify  | 0.061952   | 0.061952   | 0.061952   |   0.0 |  0.25
Other   |            | 0.005405   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128068 ave      128068 max      128068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128068
Ave neighs/atom = 64.034
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.011370379496, Press = 1.37233874819548
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8417.5321     -8417.5321     -8497.2693     -8497.2693      308.59113      308.59113      23684.987      23684.987      3534.6346      3534.6346    
     34000  -8414.0144     -8414.0144     -8496.7981     -8496.7981      320.38122      320.38122      23723.403      23723.403      974.64838      974.64838    
Loop time of 24.9347 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.465 ns/day, 6.926 hours/ns, 40.105 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.852     | 24.852     | 24.852     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015181   | 0.015181   | 0.015181   |   0.0 |  0.06
Output  | 2.8534e-05 | 2.8534e-05 | 2.8534e-05 |   0.0 |  0.00
Modify  | 0.061982   | 0.061982   | 0.061982   |   0.0 |  0.25
Other   |            | 0.005418   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128098 ave      128098 max      128098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128098
Ave neighs/atom = 64.049
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.020882174165, Press = 0.261556324696758
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8414.0144     -8414.0144     -8496.7981     -8496.7981      320.38122      320.38122      23723.403      23723.403      974.64838      974.64838    
     35000  -8417.0636     -8417.0636     -8496.1928     -8496.1928      306.23802      306.23802      23737.018      23737.018     -25.670771     -25.670771    
Loop time of 25.0314 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.452 ns/day, 6.953 hours/ns, 39.950 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.949     | 24.949     | 24.949     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015145   | 0.015145   | 0.015145   |   0.0 |  0.06
Output  | 2.4435e-05 | 2.4435e-05 | 2.4435e-05 |   0.0 |  0.00
Modify  | 0.062083   | 0.062083   | 0.062083   |   0.0 |  0.25
Other   |            | 0.005424   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128060 ave      128060 max      128060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128060
Ave neighs/atom = 64.03
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.033095561822, Press = 1.0006902231955
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8417.0636     -8417.0636     -8496.1928     -8496.1928      306.23802      306.23802      23737.018      23737.018     -25.670771     -25.670771    
     36000  -8414.2705     -8414.2705     -8495.0091     -8495.0091      312.46686      312.46686      23742.861      23742.861     -141.10401     -141.10401    
Loop time of 25.1314 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.438 ns/day, 6.981 hours/ns, 39.791 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.048     | 25.048     | 25.048     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01534    | 0.01534    | 0.01534    |   0.0 |  0.06
Output  | 2.3905e-05 | 2.3905e-05 | 2.3905e-05 |   0.0 |  0.00
Modify  | 0.062237   | 0.062237   | 0.062237   |   0.0 |  0.25
Other   |            | 0.005405   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128032 ave      128032 max      128032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128032
Ave neighs/atom = 64.016
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.022768036092, Press = 1.14347405090484
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8414.2705     -8414.2705     -8495.0091     -8495.0091      312.46686      312.46686      23742.861      23742.861     -141.10401     -141.10401    
     37000  -8417.7807     -8417.7807     -8497.175      -8497.175       307.26392      307.26392      23741.571      23741.571     -538.29338     -538.29338    
Loop time of 25.1514 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.435 ns/day, 6.986 hours/ns, 39.759 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.068     | 25.068     | 25.068     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015248   | 0.015248   | 0.015248   |   0.0 |  0.06
Output  | 4.7499e-05 | 4.7499e-05 | 4.7499e-05 |   0.0 |  0.00
Modify  | 0.0625     | 0.0625     | 0.0625     |   0.0 |  0.25
Other   |            | 0.00545    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 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:       128044 ave      128044 max      128044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128044
Ave neighs/atom = 64.022
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.935040388012, Press = 1.37742555433158
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8417.7807     -8417.7807     -8497.175      -8497.175       307.26392      307.26392      23741.571      23741.571     -538.29338     -538.29338    
     38000  -8415.5505     -8415.5505     -8495.7258     -8495.7258      310.28663      310.28663      23737.288      23737.288      91.021019      91.021019    
Loop time of 25.2099 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.427 ns/day, 7.003 hours/ns, 39.667 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.126     | 25.126     | 25.126     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015281   | 0.015281   | 0.015281   |   0.0 |  0.06
Output  | 2.5308e-05 | 2.5308e-05 | 2.5308e-05 |   0.0 |  0.00
Modify  | 0.062655   | 0.062655   | 0.062655   |   0.0 |  0.25
Other   |            | 0.005417   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 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:       128070 ave      128070 max      128070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128070
Ave neighs/atom = 64.035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.972308492674, Press = 2.08842325190568
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8415.5505     -8415.5505     -8495.7258     -8495.7258      310.28663      310.28663      23737.288      23737.288      91.021019      91.021019    
     39000  -8417.8357     -8417.8357     -8496.1108     -8496.1108      302.93269      302.93269      23723.573      23723.573      1005.3156      1005.3156    
Loop time of 25.1581 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.434 ns/day, 6.988 hours/ns, 39.749 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.075     | 25.075     | 25.075     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01532    | 0.01532    | 0.01532    |   0.0 |  0.06
Output  | 4.7209e-05 | 4.7209e-05 | 4.7209e-05 |   0.0 |  0.00
Modify  | 0.062597   | 0.062597   | 0.062597   |   0.0 |  0.25
Other   |            | 0.00545    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 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:       128058 ave      128058 max      128058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128058
Ave neighs/atom = 64.029
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.993619442691, Press = 2.27655258062873
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8417.8357     -8417.8357     -8496.1108     -8496.1108      302.93269      302.93269      23723.573      23723.573      1005.3156      1005.3156    
     40000  -8414.3539     -8414.3539     -8497.079      -8497.079       320.15438      320.15438      23702.887      23702.887      2349.5198      2349.5198    
Loop time of 25.2193 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.426 ns/day, 7.005 hours/ns, 39.652 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.135     | 25.135     | 25.135     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015444   | 0.015444   | 0.015444   |   0.0 |  0.06
Output  | 2.3885e-05 | 2.3885e-05 | 2.3885e-05 |   0.0 |  0.00
Modify  | 0.062924   | 0.062924   | 0.062924   |   0.0 |  0.25
Other   |            | 0.005479   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128078 ave      128078 max      128078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128078
Ave neighs/atom = 64.039
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.008855998333, Press = 2.16160424033361
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8414.3539     -8414.3539     -8497.079      -8497.079       320.15438      320.15438      23702.887      23702.887      2349.5198      2349.5198    
     41000  -8414.6429     -8414.6429     -8495.5971     -8495.5971      313.30104      313.30104      23687.345      23687.345      3759.416       3759.416     
Loop time of 25.3296 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.411 ns/day, 7.036 hours/ns, 39.479 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.246     | 25.246     | 25.246     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01536    | 0.01536    | 0.01536    |   0.0 |  0.06
Output  | 3.6389e-05 | 3.6389e-05 | 3.6389e-05 |   0.0 |  0.00
Modify  | 0.062836   | 0.062836   | 0.062836   |   0.0 |  0.25
Other   |            | 0.005458   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128096 ave      128096 max      128096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128096
Ave neighs/atom = 64.048
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.01175562035, Press = 0.737898457738949
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8414.6429     -8414.6429     -8495.5971     -8495.5971      313.30104      313.30104      23687.345      23687.345      3759.416       3759.416     
     42000  -8416.6415     -8416.6415     -8496.3337     -8496.3337      308.41725      308.41725      23711.608      23711.608      1810.9741      1810.9741    
Loop time of 25.2162 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.426 ns/day, 7.005 hours/ns, 39.657 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.133     | 25.133     | 25.133     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015316   | 0.015316   | 0.015316   |   0.0 |  0.06
Output  | 2.4887e-05 | 2.4887e-05 | 2.4887e-05 |   0.0 |  0.00
Modify  | 0.062634   | 0.062634   | 0.062634   |   0.0 |  0.25
Other   |            | 0.00547    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 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:       128052 ave      128052 max      128052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128052
Ave neighs/atom = 64.026
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.004912618947, Press = -0.24850612964231
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8416.6415     -8416.6415     -8496.3337     -8496.3337      308.41725      308.41725      23711.608      23711.608      1810.9741      1810.9741    
     43000  -8415.1517     -8415.1517     -8498.3668     -8498.3668      322.05116      322.05116      23738.974      23738.974     -373.02621     -373.02621    
Loop time of 25.1932 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.429 ns/day, 6.998 hours/ns, 39.693 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.11      | 25.11      | 25.11      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015443   | 0.015443   | 0.015443   |   0.0 |  0.06
Output  | 2.4707e-05 | 2.4707e-05 | 2.4707e-05 |   0.0 |  0.00
Modify  | 0.062616   | 0.062616   | 0.062616   |   0.0 |  0.25
Other   |            | 0.005466   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 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:       128084 ave      128084 max      128084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128084
Ave neighs/atom = 64.042
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.910686366074, Press = -0.0772677734724221
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8415.1517     -8415.1517     -8498.3668     -8498.3668      322.05116      322.05116      23738.974      23738.974     -373.02621     -373.02621    
     44000  -8413.3128     -8413.3128     -8495.5482     -8495.5482      318.25966      318.25966      23755.693      23755.693     -1091.4346     -1091.4346    
Loop time of 25.1295 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.438 ns/day, 6.980 hours/ns, 39.794 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.046     | 25.046     | 25.046     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01535    | 0.01535    | 0.01535    |   0.0 |  0.06
Output  | 4.7789e-05 | 4.7789e-05 | 4.7789e-05 |   0.0 |  0.00
Modify  | 0.062682   | 0.062682   | 0.062682   |   0.0 |  0.25
Other   |            | 0.005486   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128038 ave      128038 max      128038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128038
Ave neighs/atom = 64.019
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.930299016095, Press = 0.0033460703593817
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8413.3128     -8413.3128     -8495.5482     -8495.5482      318.25966      318.25966      23755.693      23755.693     -1091.4346     -1091.4346    
     45000  -8414.674      -8414.674      -8496.7367     -8496.7367      317.5912       317.5912       23766.1        23766.1       -2095.6372     -2095.6372    
Loop time of 25.1622 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.434 ns/day, 6.990 hours/ns, 39.742 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.079     | 25.079     | 25.079     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015298   | 0.015298   | 0.015298   |   0.0 |  0.06
Output  | 2.4806e-05 | 2.4806e-05 | 2.4806e-05 |   0.0 |  0.00
Modify  | 0.062617   | 0.062617   | 0.062617   |   0.0 |  0.25
Other   |            | 0.005416   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128082 ave      128082 max      128082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128082
Ave neighs/atom = 64.041
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.953904591497, Press = 1.03077626376375
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8414.674      -8414.674      -8496.7367     -8496.7367      317.5912       317.5912       23766.1        23766.1       -2095.6372     -2095.6372    
     46000  -8411.4253     -8411.4253     -8493.2309     -8493.2309      316.59624      316.59624      23797.611      23797.611     -3587.1962     -3587.1962    
Loop time of 25.2764 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.418 ns/day, 7.021 hours/ns, 39.563 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.193     | 25.193     | 25.193     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015267   | 0.015267   | 0.015267   |   0.0 |  0.06
Output  | 4.6327e-05 | 4.6327e-05 | 4.6327e-05 |   0.0 |  0.00
Modify  | 0.062624   | 0.062624   | 0.062624   |   0.0 |  0.25
Other   |            | 0.005467   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128066 ave      128066 max      128066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128066
Ave neighs/atom = 64.033
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.024728470768, Press = 2.59149619522957
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8411.4253     -8411.4253     -8493.2309     -8493.2309      316.59624      316.59624      23797.611      23797.611     -3587.1962     -3587.1962    
     47000  -8413.8917     -8413.8917     -8495.7049     -8495.7049      316.6256       316.6256       23752.133      23752.133     -843.34983     -843.34983    
Loop time of 25.1624 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.434 ns/day, 6.990 hours/ns, 39.742 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.079     | 25.079     | 25.079     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015408   | 0.015408   | 0.015408   |   0.0 |  0.06
Output  | 2.4265e-05 | 2.4265e-05 | 2.4265e-05 |   0.0 |  0.00
Modify  | 0.062965   | 0.062965   | 0.062965   |   0.0 |  0.25
Other   |            | 0.005467   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 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:       128002 ave      128002 max      128002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128002
Ave neighs/atom = 64.001
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.050070002651, Press = 3.20307515850504
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8413.8917     -8413.8917     -8495.7049     -8495.7049      316.6256       316.6256       23752.133      23752.133     -843.34983     -843.34983    
     48000  -8417.8627     -8417.8627     -8497.0754     -8497.0754      306.5611       306.5611       23727.104      23727.104      555.81274      555.81274    
Loop time of 25.2277 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.425 ns/day, 7.008 hours/ns, 39.639 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.144     | 25.144     | 25.144     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015371   | 0.015371   | 0.015371   |   0.0 |  0.06
Output  | 2.5067e-05 | 2.5067e-05 | 2.5067e-05 |   0.0 |  0.00
Modify  | 0.062699   | 0.062699   | 0.062699   |   0.0 |  0.25
Other   |            | 0.005419   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128024 ave      128024 max      128024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128024
Ave neighs/atom = 64.012
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.093375432004, Press = 1.99376513156115
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8417.8627     -8417.8627     -8497.0754     -8497.0754      306.5611       306.5611       23727.104      23727.104      555.81274      555.81274    
     49000  -8413.6438     -8413.6438     -8496.7426     -8496.7426      321.60077      321.60077      23728.171      23728.171      724.90913      724.90913    
Loop time of 25.1687 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.433 ns/day, 6.991 hours/ns, 39.732 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.085     | 25.085     | 25.085     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015419   | 0.015419   | 0.015419   |   0.0 |  0.06
Output  | 4.7038e-05 | 4.7038e-05 | 4.7038e-05 |   0.0 |  0.00
Modify  | 0.062803   | 0.062803   | 0.062803   |   0.0 |  0.25
Other   |            | 0.00547    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128050 ave      128050 max      128050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128050
Ave neighs/atom = 64.025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.062402034449, Press = 1.56317757045427
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8413.6438     -8413.6438     -8496.7426     -8496.7426      321.60077      321.60077      23728.171      23728.171      724.90913      724.90913    
     50000  -8418.1533     -8418.1533     -8496.4482     -8496.4482      303.00935      303.00935      23712.924      23712.924      1644.2213      1644.2213    
Loop time of 25.1762 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.432 ns/day, 6.993 hours/ns, 39.720 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.093     | 25.093     | 25.093     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015283   | 0.015283   | 0.015283   |   0.0 |  0.06
Output  | 2.4717e-05 | 2.4717e-05 | 2.4717e-05 |   0.0 |  0.00
Modify  | 0.062719   | 0.062719   | 0.062719   |   0.0 |  0.25
Other   |            | 0.005468   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128040 ave      128040 max      128040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128040
Ave neighs/atom = 64.02
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.997095283862, Press = 1.03708266287489
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8418.1533     -8418.1533     -8496.4482     -8496.4482      303.00935      303.00935      23712.924      23712.924      1644.2213      1644.2213    
     51000  -8414.5736     -8414.5736     -8494.7841     -8494.7841      310.42288      310.42288      23691.699      23691.699      3552.0619      3552.0619    
Loop time of 25.1093 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.441 ns/day, 6.975 hours/ns, 39.826 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.026     | 25.026     | 25.026     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015264   | 0.015264   | 0.015264   |   0.0 |  0.06
Output  | 4.6537e-05 | 4.6537e-05 | 4.6537e-05 |   0.0 |  0.00
Modify  | 0.062741   | 0.062741   | 0.062741   |   0.0 |  0.25
Other   |            | 0.005457   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128056 ave      128056 max      128056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0