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

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

kim_interactions Pt

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

kim interactions Pt
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtTi__MO_280985530673_002
pair_coeff * * Pt
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 195.078

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -22918.129     -22918.129     -23080         -23080          313.15         313.15         60115.2        60115.2        2876.087       2876.087     
      1000  -22748.002     -22748.002     -22919.059     -22919.059      330.92188      330.92188      60739.134      60739.134     -2735.3133     -2735.3133    
Loop time of 40.0967 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.155 ns/day, 11.138 hours/ns, 24.940 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    | 39.945     | 39.945     | 39.945     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022603   | 0.022603   | 0.022603   |   0.0 |  0.06
Output  | 0.0001354  | 0.0001354  | 0.0001354  |   0.0 |  0.00
Modify  | 0.11782    | 0.11782    | 0.11782    |   0.0 |  0.29
Other   |            | 0.01086    |            |       |  0.03

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

Total # of neighbors = 344000
Ave neighs/atom = 86
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -22748.002     -22748.002     -22919.059     -22919.059      330.92188      330.92188      60739.134      60739.134     -2735.3133     -2735.3133    
      2000  -22756.51      -22756.51      -22923.269     -22923.269      322.60775      322.60775      60686.67       60686.67      -1067.3118     -1067.3118    
Loop time of 44.6872 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.933 ns/day, 12.413 hours/ns, 22.378 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    | 44.537     | 44.537     | 44.537     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021688   | 0.021688   | 0.021688   |   0.0 |  0.05
Output  | 6.1135e-05 | 6.1135e-05 | 6.1135e-05 |   0.0 |  0.00
Modify  | 0.11769    | 0.11769    | 0.11769    |   0.0 |  0.26
Other   |            | 0.01074    |            |       |  0.02

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

Total # of neighbors = 326622
Ave neighs/atom = 81.6555
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -22756.51      -22756.51      -22923.269     -22923.269      322.60775      322.60775      60686.67       60686.67      -1067.3118     -1067.3118    
      3000  -22758.464     -22758.464     -22923.823     -22923.823      319.89695      319.89695      60691.549      60691.549     -1433.6639     -1433.6639    
Loop time of 44.9969 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.920 ns/day, 12.499 hours/ns, 22.224 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    | 44.846     | 44.846     | 44.846     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021905   | 0.021905   | 0.021905   |   0.0 |  0.05
Output  | 5.9522e-05 | 5.9522e-05 | 5.9522e-05 |   0.0 |  0.00
Modify  | 0.11796    | 0.11796    | 0.11796    |   0.0 |  0.26
Other   |            | 0.01087    |            |       |  0.02

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

Total # of neighbors = 326952
Ave neighs/atom = 81.738
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -22758.464     -22758.464     -22923.823     -22923.823      319.89695      319.89695      60691.549      60691.549     -1433.6639     -1433.6639    
      4000  -22753.324     -22753.324     -22920.512     -22920.512      323.43652      323.43652      60628.318      60628.318      2311.0192      2311.0192    
Loop time of 44.8158 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.928 ns/day, 12.449 hours/ns, 22.314 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    | 44.665     | 44.665     | 44.665     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021709   | 0.021709   | 0.021709   |   0.0 |  0.05
Output  | 6.404e-05  | 6.404e-05  | 6.404e-05  |   0.0 |  0.00
Modify  | 0.11794    | 0.11794    | 0.11794    |   0.0 |  0.26
Other   |            | 0.01069    |            |       |  0.02

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

Total # of neighbors = 326816
Ave neighs/atom = 81.704
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -22753.324     -22753.324     -22920.512     -22920.512      323.43652      323.43652      60628.318      60628.318      2311.0192      2311.0192    
      5000  -22758.552     -22758.552     -22917.089     -22917.089      306.70073      306.70073      60714.536      60714.536     -1675.9861     -1675.9861    
Loop time of 44.9433 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.922 ns/day, 12.484 hours/ns, 22.250 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    | 44.792     | 44.792     | 44.792     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021819   | 0.021819   | 0.021819   |   0.0 |  0.05
Output  | 4.6648e-05 | 4.6648e-05 | 4.6648e-05 |   0.0 |  0.00
Modify  | 0.11841    | 0.11841    | 0.11841    |   0.0 |  0.26
Other   |            | 0.01077    |            |       |  0.02

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

Total # of neighbors = 327302
Ave neighs/atom = 81.8255
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 = 316.113307262619, Press = 504.948587215368
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -22758.552     -22758.552     -22917.089     -22917.089      306.70073      306.70073      60714.536      60714.536     -1675.9861     -1675.9861    
      6000  -22757.807     -22757.807     -22921.574     -22921.574      316.81813      316.81813      60618.93       60618.93       2344.1853      2344.1853    
Loop time of 44.931 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.923 ns/day, 12.481 hours/ns, 22.256 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    | 44.777     | 44.777     | 44.777     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021778   | 0.021778   | 0.021778   |   0.0 |  0.05
Output  | 4.9002e-05 | 4.9002e-05 | 4.9002e-05 |   0.0 |  0.00
Modify  | 0.12144    | 0.12144    | 0.12144    |   0.0 |  0.27
Other   |            | 0.01078    |            |       |  0.02

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

Total # of neighbors = 326680
Ave neighs/atom = 81.67
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.585576201284, Press = 42.2740324569896
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -22757.807     -22757.807     -22921.574     -22921.574      316.81813      316.81813      60618.93       60618.93       2344.1853      2344.1853    
      7000  -22754.957     -22754.957     -22917.17      -22917.17       313.8125       313.8125       60693.822      60693.822     -615.57309     -615.57309    
Loop time of 44.9856 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.921 ns/day, 12.496 hours/ns, 22.229 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    | 44.832     | 44.832     | 44.832     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021586   | 0.021586   | 0.021586   |   0.0 |  0.05
Output  | 3.71e-05   | 3.71e-05   | 3.71e-05   |   0.0 |  0.00
Modify  | 0.12143    | 0.12143    | 0.12143    |   0.0 |  0.27
Other   |            | 0.01074    |            |       |  0.02

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

Total # of neighbors = 327400
Ave neighs/atom = 81.85
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.987105927339, Press = 10.0552581502516
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -22754.957     -22754.957     -22917.17      -22917.17       313.8125       313.8125       60693.822      60693.822     -615.57309     -615.57309    
      8000  -22757.677     -22757.677     -22919.102     -22919.102      312.28789      312.28789      60670.182      60670.182      333.63483      333.63483    
Loop time of 44.9136 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.924 ns/day, 12.476 hours/ns, 22.265 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    | 44.76      | 44.76      | 44.76      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021636   | 0.021636   | 0.021636   |   0.0 |  0.05
Output  | 4.8491e-05 | 4.8491e-05 | 4.8491e-05 |   0.0 |  0.00
Modify  | 0.1213     | 0.1213     | 0.1213     |   0.0 |  0.27
Other   |            | 0.01091    |            |       |  0.02

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

Total # of neighbors = 326784
Ave neighs/atom = 81.696
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.31144335872, Press = 9.1610949359865
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -22757.677     -22757.677     -22919.102     -22919.102      312.28789      312.28789      60670.182      60670.182      333.63483      333.63483    
      9000  -22757.264     -22757.264     -22920.489     -22920.489      315.76862      315.76862      60654.296      60654.296      802.71023      802.71023    
Loop time of 44.948 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.922 ns/day, 12.486 hours/ns, 22.248 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    | 44.794     | 44.794     | 44.794     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021699   | 0.021699   | 0.021699   |   0.0 |  0.05
Output  | 4.828e-05  | 4.828e-05  | 4.828e-05  |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.27
Other   |            | 0.01076    |            |       |  0.02

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

Total # of neighbors = 327034
Ave neighs/atom = 81.7585
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.150127530123, Press = 13.7274191650133
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -22757.264     -22757.264     -22920.489     -22920.489      315.76862      315.76862      60654.296      60654.296      802.71023      802.71023    
     10000  -22760.123     -22760.123     -22919.311     -22919.311      307.9603       307.9603       60659.84       60659.84       654.20644      654.20644    
Loop time of 44.9259 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.923 ns/day, 12.479 hours/ns, 22.259 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    | 44.772     | 44.772     | 44.772     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021823   | 0.021823   | 0.021823   |   0.0 |  0.05
Output  | 4.6758e-05 | 4.6758e-05 | 4.6758e-05 |   0.0 |  0.00
Modify  | 0.12161    | 0.12161    | 0.12161    |   0.0 |  0.27
Other   |            | 0.01081    |            |       |  0.02

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

Total # of neighbors = 327072
Ave neighs/atom = 81.768
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.074920426368, Press = 0.317871321954588
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -22760.123     -22760.123     -22919.311     -22919.311      307.9603       307.9603       60659.84       60659.84       654.20644      654.20644    
     11000  -22761.685     -22761.685     -22921.095     -22921.095      308.38765      308.38765      60709.437      60709.437     -1823.5142     -1823.5142    
Loop time of 44.9267 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.923 ns/day, 12.480 hours/ns, 22.258 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    | 44.773     | 44.773     | 44.773     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021713   | 0.021713   | 0.021713   |   0.0 |  0.05
Output  | 3.7109e-05 | 3.7109e-05 | 3.7109e-05 |   0.0 |  0.00
Modify  | 0.12162    | 0.12162    | 0.12162    |   0.0 |  0.27
Other   |            | 0.01078    |            |       |  0.02

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

Total # of neighbors = 327094
Ave neighs/atom = 81.7735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.730072242841, Press = 2.33237807168114
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -22761.685     -22761.685     -22921.095     -22921.095      308.38765      308.38765      60709.437      60709.437     -1823.5142     -1823.5142    
     12000  -22756.204     -22756.204     -22918.315     -22918.315      313.61382      313.61382      60680.396      60680.396     -42.0482       -42.0482      
Loop time of 44.9703 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.921 ns/day, 12.492 hours/ns, 22.237 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    | 44.816     | 44.816     | 44.816     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021689   | 0.021689   | 0.021689   |   0.0 |  0.05
Output  | 6.1336e-05 | 6.1336e-05 | 6.1336e-05 |   0.0 |  0.00
Modify  | 0.12159    | 0.12159    | 0.12159    |   0.0 |  0.27
Other   |            | 0.01083    |            |       |  0.02

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

Total # of neighbors = 326772
Ave neighs/atom = 81.693
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.686345656874, Press = 5.8190648041248
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -22756.204     -22756.204     -22918.315     -22918.315      313.61382      313.61382      60680.396      60680.396     -42.0482       -42.0482      
     13000  -22755.564     -22755.564     -22920.529     -22920.529      319.13552      319.13552      60682.718      60682.718     -423.84404     -423.84404    
Loop time of 44.869 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.926 ns/day, 12.464 hours/ns, 22.287 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    | 44.715     | 44.715     | 44.715     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021737   | 0.021737   | 0.021737   |   0.0 |  0.05
Output  | 5.34e-05   | 5.34e-05   | 5.34e-05   |   0.0 |  0.00
Modify  | 0.12169    | 0.12169    | 0.12169    |   0.0 |  0.27
Other   |            | 0.01081    |            |       |  0.02

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

Total # of neighbors = 326898
Ave neighs/atom = 81.7245
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.543748290974, Press = 7.32142026724405
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -22755.564     -22755.564     -22920.529     -22920.529      319.13552      319.13552      60682.718      60682.718     -423.84404     -423.84404    
     14000  -22758.134     -22758.134     -22922.44      -22922.44       317.86057      317.86057      60657.048      60657.048      430.16081      430.16081    
Loop time of 44.9378 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.923 ns/day, 12.483 hours/ns, 22.253 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    | 44.783     | 44.783     | 44.783     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021848   | 0.021848   | 0.021848   |   0.0 |  0.05
Output  | 4.9462e-05 | 4.9462e-05 | 4.9462e-05 |   0.0 |  0.00
Modify  | 0.12171    | 0.12171    | 0.12171    |   0.0 |  0.27
Other   |            | 0.01082    |            |       |  0.02

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

Total # of neighbors = 327080
Ave neighs/atom = 81.77
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.817788928302, Press = 3.15497484856763
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -22758.134     -22758.134     -22922.44      -22922.44       317.86057      317.86057      60657.048      60657.048      430.16081      430.16081    
     15000  -22753.448     -22753.448     -22914.993     -22914.993      312.52107      312.52107      60685.747      60685.747      152.21817      152.21817    
Loop time of 44.9286 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.923 ns/day, 12.480 hours/ns, 22.258 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    | 44.775     | 44.775     | 44.775     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021743   | 0.021743   | 0.021743   |   0.0 |  0.05
Output  | 3.245e-05  | 3.245e-05  | 3.245e-05  |   0.0 |  0.00
Modify  | 0.12154    | 0.12154    | 0.12154    |   0.0 |  0.27
Other   |            | 0.01082    |            |       |  0.02

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

Total # of neighbors = 327120
Ave neighs/atom = 81.78
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.886876653355, Press = 2.49620898944796
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -22753.448     -22753.448     -22914.993     -22914.993      312.52107      312.52107      60685.747      60685.747      152.21817      152.21817    
     16000  -22756.939     -22756.939     -22916.867     -22916.867      309.39214      309.39214      60665.752      60665.752      743.68948      743.68948    
Loop time of 44.7893 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.929 ns/day, 12.441 hours/ns, 22.327 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    | 44.635     | 44.635     | 44.635     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021812   | 0.021812   | 0.021812   |   0.0 |  0.05
Output  | 5.4082e-05 | 5.4082e-05 | 5.4082e-05 |   0.0 |  0.00
Modify  | 0.12155    | 0.12155    | 0.12155    |   0.0 |  0.27
Other   |            | 0.01081    |            |       |  0.02

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

Total # of neighbors = 326982
Ave neighs/atom = 81.7455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.046625158252, Press = 2.66838904480405
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -22756.939     -22756.939     -22916.867     -22916.867      309.39214      309.39214      60665.752      60665.752      743.68948      743.68948    
     17000  -22760.329     -22760.329     -22919.642     -22919.642      308.20097      308.20097      60647.805      60647.805      1156.9554      1156.9554    
Loop time of 44.8507 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.926 ns/day, 12.459 hours/ns, 22.296 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    | 44.696     | 44.696     | 44.696     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02181    | 0.02181    | 0.02181    |   0.0 |  0.05
Output  | 5.2278e-05 | 5.2278e-05 | 5.2278e-05 |   0.0 |  0.00
Modify  | 0.12196    | 0.12196    | 0.12196    |   0.0 |  0.27
Other   |            | 0.01085    |            |       |  0.02

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

Total # of neighbors = 326918
Ave neighs/atom = 81.7295
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.931847545114, Press = 4.33771865827549
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -22760.329     -22760.329     -22919.642     -22919.642      308.20097      308.20097      60647.805      60647.805      1156.9554      1156.9554    
     18000  -22755.916     -22755.916     -22916.856     -22916.856      311.34962      311.34962      60651.239      60651.239      1438.067       1438.067     
Loop time of 44.9683 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.921 ns/day, 12.491 hours/ns, 22.238 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    | 44.814     | 44.814     | 44.814     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021785   | 0.021785   | 0.021785   |   0.0 |  0.05
Output  | 4.7008e-05 | 4.7008e-05 | 4.7008e-05 |   0.0 |  0.00
Modify  | 0.12193    | 0.12193    | 0.12193    |   0.0 |  0.27
Other   |            | 0.01084    |            |       |  0.02

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

Total # of neighbors = 327032
Ave neighs/atom = 81.758
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.924268006191, Press = 0.989333586372035
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -22755.916     -22755.916     -22916.856     -22916.856      311.34962      311.34962      60651.239      60651.239      1438.067       1438.067     
     19000  -22757.502     -22757.502     -22919.683     -22919.683      313.75005      313.75005      60748.945      60748.945     -3426.3354     -3426.3354    
Loop time of 45.2729 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.908 ns/day, 12.576 hours/ns, 22.088 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 45.118     | 45.118     | 45.118     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021893   | 0.021893   | 0.021893   |   0.0 |  0.05
Output  | 3.5407e-05 | 3.5407e-05 | 3.5407e-05 |   0.0 |  0.00
Modify  | 0.1225     | 0.1225     | 0.1225     |   0.0 |  0.27
Other   |            | 0.01085    |            |       |  0.02

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

Total # of neighbors = 327118
Ave neighs/atom = 81.7795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.968845223971, Press = 2.7641383052187
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -22757.502     -22757.502     -22919.683     -22919.683      313.75005      313.75005      60748.945      60748.945     -3426.3354     -3426.3354    
     20000  -22758.164     -22758.164     -22919.961     -22919.961      313.00829      313.00829      60638.937      60638.937      1714.697       1714.697     
Loop time of 44.8143 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.928 ns/day, 12.448 hours/ns, 22.314 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    | 44.66      | 44.66      | 44.66      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021758   | 0.021758   | 0.021758   |   0.0 |  0.05
Output  | 5.5825e-05 | 5.5825e-05 | 5.5825e-05 |   0.0 |  0.00
Modify  | 0.12159    | 0.12159    | 0.12159    |   0.0 |  0.27
Other   |            | 0.01084    |            |       |  0.02

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

Total # of neighbors = 326648
Ave neighs/atom = 81.662
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.900676845299, Press = 1.64443852751772
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -22758.164     -22758.164     -22919.961     -22919.961      313.00829      313.00829      60638.937      60638.937      1714.697       1714.697     
     21000  -22758.954     -22758.954     -22920.637     -22920.637      312.7857       312.7857       60640.477      60640.477      1447.4379      1447.4379    
Loop time of 44.891 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.925 ns/day, 12.470 hours/ns, 22.276 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.737     | 44.737     | 44.737     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021728   | 0.021728   | 0.021728   |   0.0 |  0.05
Output  | 5.4512e-05 | 5.4512e-05 | 5.4512e-05 |   0.0 |  0.00
Modify  | 0.12145    | 0.12145    | 0.12145    |   0.0 |  0.27
Other   |            | 0.01087    |            |       |  0.02

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

Total # of neighbors = 327188
Ave neighs/atom = 81.797
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.006632678658, Press = 2.87219162646198
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -22758.954     -22758.954     -22920.637     -22920.637      312.7857       312.7857       60640.477      60640.477      1447.4379      1447.4379    
     22000  -22752.971     -22752.971     -22916.447     -22916.447      316.25548      316.25548      60631.806      60631.806      2519.0274      2519.0274    
Loop time of 44.9741 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.921 ns/day, 12.493 hours/ns, 22.235 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    | 44.82      | 44.82      | 44.82      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021833   | 0.021833   | 0.021833   |   0.0 |  0.05
Output  | 4.9272e-05 | 4.9272e-05 | 4.9272e-05 |   0.0 |  0.00
Modify  | 0.12157    | 0.12157    | 0.12157    |   0.0 |  0.27
Other   |            | 0.01084    |            |       |  0.02

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

Total # of neighbors = 327146
Ave neighs/atom = 81.7865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.068270118982, Press = 2.90184875005639
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -22752.971     -22752.971     -22916.447     -22916.447      316.25548      316.25548      60631.806      60631.806      2519.0274      2519.0274    
     23000  -22757.692     -22757.692     -22918.961     -22918.961      311.98554      311.98554      60691.549      60691.549     -667.13504     -667.13504    
Loop time of 44.8513 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.926 ns/day, 12.459 hours/ns, 22.296 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.697     | 44.697     | 44.697     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021694   | 0.021694   | 0.021694   |   0.0 |  0.05
Output  | 3.3813e-05 | 3.3813e-05 | 3.3813e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.27
Other   |            | 0.01092    |            |       |  0.02

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

Total # of neighbors = 327182
Ave neighs/atom = 81.7955
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.080634301071, Press = 1.04741856501838
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -22757.692     -22757.692     -22918.961     -22918.961      311.98554      311.98554      60691.549      60691.549     -667.13504     -667.13504    
     24000  -22748.447     -22748.447     -22914.355     -22914.355      320.95921      320.95921      60730.848      60730.848     -1895.7391     -1895.7391    
Loop time of 44.8714 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.926 ns/day, 12.464 hours/ns, 22.286 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.718     | 44.718     | 44.718     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021681   | 0.021681   | 0.021681   |   0.0 |  0.05
Output  | 5.4883e-05 | 5.4883e-05 | 5.4883e-05 |   0.0 |  0.00
Modify  | 0.12116    | 0.12116    | 0.12116    |   0.0 |  0.27
Other   |            | 0.01081    |            |       |  0.02

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

Total # of neighbors = 326950
Ave neighs/atom = 81.7375
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.172353928283, Press = 0.577968748359012
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -22748.447     -22748.447     -22914.355     -22914.355      320.95921      320.95921      60730.848      60730.848     -1895.7391     -1895.7391    
     25000  -22758.422     -22758.422     -22917.774     -22917.774      308.27789      308.27789      60631.139      60631.139      2248.1888      2248.1888    
Loop time of 44.9013 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.924 ns/day, 12.473 hours/ns, 22.271 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.747     | 44.747     | 44.747     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021799   | 0.021799   | 0.021799   |   0.0 |  0.05
Output  | 5.4342e-05 | 5.4342e-05 | 5.4342e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.27
Other   |            | 0.01082    |            |       |  0.02

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

Total # of neighbors = 326632
Ave neighs/atom = 81.658
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.241629007313, Press = 2.2850640214788
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -22758.422     -22758.422     -22917.774     -22917.774      308.27789      308.27789      60631.139      60631.139      2248.1888      2248.1888    
     26000  -22751.159     -22751.159     -22916.843     -22916.843      320.52767      320.52767      60699.515      60699.515     -617.29495     -617.29495    
Loop time of 44.8488 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.926 ns/day, 12.458 hours/ns, 22.297 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.695     | 44.695     | 44.695     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021749   | 0.021749   | 0.021749   |   0.0 |  0.05
Output  | 4.9373e-05 | 4.9373e-05 | 4.9373e-05 |   0.0 |  0.00
Modify  | 0.12101    | 0.12101    | 0.12101    |   0.0 |  0.27
Other   |            | 0.01078    |            |       |  0.02

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

Total # of neighbors = 327106
Ave neighs/atom = 81.7765
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.280381429848, Press = -0.475214342422747
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -22751.159     -22751.159     -22916.843     -22916.843      320.52767      320.52767      60699.515      60699.515     -617.29495     -617.29495    
     27000  -22760.2       -22760.2       -22922.699     -22922.699      314.36437      314.36437      60666.44       60666.44      -11.425008     -11.425008    
Loop time of 44.8887 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.925 ns/day, 12.469 hours/ns, 22.277 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.735     | 44.735     | 44.735     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021615   | 0.021615   | 0.021615   |   0.0 |  0.05
Output  | 3.2621e-05 | 3.2621e-05 | 3.2621e-05 |   0.0 |  0.00
Modify  | 0.12112    | 0.12112    | 0.12112    |   0.0 |  0.27
Other   |            | 0.01075    |            |       |  0.02

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

Total # of neighbors = 326814
Ave neighs/atom = 81.7035
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.354775648273, Press = 2.76150672498359
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -22760.2       -22760.2       -22922.699     -22922.699      314.36437      314.36437      60666.44       60666.44      -11.425008     -11.425008    
     28000  -22756.587     -22756.587     -22917.912     -22917.912      312.09533      312.09533      60677.952      60677.952     -34.97499      -34.97499     
Loop time of 44.8067 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.928 ns/day, 12.446 hours/ns, 22.318 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.653     | 44.653     | 44.653     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021796   | 0.021796   | 0.021796   |   0.0 |  0.05
Output  | 5.3852e-05 | 5.3852e-05 | 5.3852e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.27
Other   |            | 0.01081    |            |       |  0.02

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

Total # of neighbors = 327070
Ave neighs/atom = 81.7675
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.341185859322, Press = 1.20319180588356
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -22756.587     -22756.587     -22917.912     -22917.912      312.09533      312.09533      60677.952      60677.952     -34.97499      -34.97499     
     29000  -22760.92      -22760.92      -22919.153     -22919.153      306.1126       306.1126       60667.276      60667.276      277.77399      277.77399    
Loop time of 44.8188 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.928 ns/day, 12.450 hours/ns, 22.312 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.665     | 44.665     | 44.665     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021803   | 0.021803   | 0.021803   |   0.0 |  0.05
Output  | 5.2899e-05 | 5.2899e-05 | 5.2899e-05 |   0.0 |  0.00
Modify  | 0.12143    | 0.12143    | 0.12143    |   0.0 |  0.27
Other   |            | 0.01078    |            |       |  0.02

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

Total # of neighbors = 327016
Ave neighs/atom = 81.754
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.300693145733, Press = 0.368825018392433
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -22760.92      -22760.92      -22919.153     -22919.153      306.1126       306.1126       60667.276      60667.276      277.77399      277.77399    
     30000  -22753.832     -22753.832     -22916.154     -22916.154      314.02334      314.02334      60623.359      60623.359      2793.1725      2793.1725    
Loop time of 44.8812 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.925 ns/day, 12.467 hours/ns, 22.281 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.727     | 44.727     | 44.727     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021698   | 0.021698   | 0.021698   |   0.0 |  0.05
Output  | 4.816e-05  | 4.816e-05  | 4.816e-05  |   0.0 |  0.00
Modify  | 0.12153    | 0.12153    | 0.12153    |   0.0 |  0.27
Other   |            | 0.01081    |            |       |  0.02

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

Total # of neighbors = 326958
Ave neighs/atom = 81.7395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.363988561137, Press = 2.91017819185582
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -22753.832     -22753.832     -22916.154     -22916.154      314.02334      314.02334      60623.359      60623.359      2793.1725      2793.1725    
     31000  -22757.182     -22757.182     -22919.62      -22919.62       314.24754      314.24754      60690.254      60690.254     -756.92573     -756.92573    
Loop time of 44.96 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.922 ns/day, 12.489 hours/ns, 22.242 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.806     | 44.806     | 44.806     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021628   | 0.021628   | 0.021628   |   0.0 |  0.05
Output  | 3.3172e-05 | 3.3172e-05 | 3.3172e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.27
Other   |            | 0.01078    |            |       |  0.02

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

Total # of neighbors = 327160
Ave neighs/atom = 81.79
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.380077557682, Press = 0.746392754415706
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -22757.182     -22757.182     -22919.62      -22919.62       314.24754      314.24754      60690.254      60690.254     -756.92573     -756.92573    
     32000  -22757.873     -22757.873     -22922.323     -22922.323      318.14047      318.14047      60681.532      60681.532     -630.46673     -630.46673    
Loop time of 44.9555 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.922 ns/day, 12.488 hours/ns, 22.244 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.801     | 44.801     | 44.801     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021667   | 0.021667   | 0.021667   |   0.0 |  0.05
Output  | 5.3801e-05 | 5.3801e-05 | 5.3801e-05 |   0.0 |  0.00
Modify  | 0.1214     | 0.1214     | 0.1214     |   0.0 |  0.27
Other   |            | 0.0109     |            |       |  0.02

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

Total # of neighbors = 326834
Ave neighs/atom = 81.7085
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.425070550402, Press = 1.96346162165916
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -22757.873     -22757.873     -22922.323     -22922.323      318.14047      318.14047      60681.532      60681.532     -630.46673     -630.46673    
     33000  -22755.715     -22755.715     -22919.269     -22919.269      316.4058       316.4058       60659.635      60659.635      808.6116       808.6116     
Loop time of 44.9274 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.923 ns/day, 12.480 hours/ns, 22.258 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.774     | 44.774     | 44.774     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021716   | 0.021716   | 0.021716   |   0.0 |  0.05
Output  | 5.3741e-05 | 5.3741e-05 | 5.3741e-05 |   0.0 |  0.00
Modify  | 0.1213     | 0.1213     | 0.1213     |   0.0 |  0.27
Other   |            | 0.01079    |            |       |  0.02

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

Total # of neighbors = 326830
Ave neighs/atom = 81.7075
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.45807573973, Press = 0.0434097405467115
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -22755.715     -22755.715     -22919.269     -22919.269      316.4058       316.4058       60659.635      60659.635      808.6116       808.6116     
     34000  -22758.163     -22758.163     -22918.8       -22918.8        310.7628       310.7628       60714.289      60714.289     -1770.5921     -1770.5921    
Loop time of 44.9721 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.921 ns/day, 12.492 hours/ns, 22.236 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.818     | 44.818     | 44.818     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021727   | 0.021727   | 0.021727   |   0.0 |  0.05
Output  | 4.81e-05   | 4.81e-05   | 4.81e-05   |   0.0 |  0.00
Modify  | 0.12129    | 0.12129    | 0.12129    |   0.0 |  0.27
Other   |            | 0.0108     |            |       |  0.02

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

Total # of neighbors = 327086
Ave neighs/atom = 81.7715
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.4279503476, Press = 2.45890828563749
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -22758.163     -22758.163     -22918.8       -22918.8        310.7628       310.7628       60714.289      60714.289     -1770.5921     -1770.5921    
     35000  -22755.816     -22755.816     -22919.811     -22919.811      317.25987      317.25987      60643.79       60643.79       1542.9826      1542.9826    
Loop time of 44.9605 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.922 ns/day, 12.489 hours/ns, 22.242 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.807     | 44.807     | 44.807     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021656   | 0.021656   | 0.021656   |   0.0 |  0.05
Output  | 3.3093e-05 | 3.3093e-05 | 3.3093e-05 |   0.0 |  0.00
Modify  | 0.1214     | 0.1214     | 0.1214     |   0.0 |  0.27
Other   |            | 0.01077    |            |       |  0.02

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

Total # of neighbors = 326620
Ave neighs/atom = 81.655
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.473976887491, Press = 1.97964014580997
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -22755.816     -22755.816     -22919.811     -22919.811      317.25987      317.25987      60643.79       60643.79       1542.9826      1542.9826    
     36000  -22759.698     -22759.698     -22918.76      -22918.76       307.71545      307.71545      60683.868      60683.868     -348.49818     -348.49818    
Loop time of 45.0132 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.919 ns/day, 12.504 hours/ns, 22.216 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    | 44.859     | 44.859     | 44.859     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02176    | 0.02176    | 0.02176    |   0.0 |  0.05
Output  | 5.4723e-05 | 5.4723e-05 | 5.4723e-05 |   0.0 |  0.00
Modify  | 0.12138    | 0.12138    | 0.12138    |   0.0 |  0.27
Other   |            | 0.01098    |            |       |  0.02

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

Total # of neighbors = 327198
Ave neighs/atom = 81.7995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.503503116352, Press = -0.344911210789881
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -22759.698     -22759.698     -22918.76      -22918.76       307.71545      307.71545      60683.868      60683.868     -348.49818     -348.49818    
     37000  -22757.862     -22757.862     -22922.014     -22922.014      317.56164      317.56164      60677.505      60677.505     -485.86182     -485.86182    
Loop time of 44.8646 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.926 ns/day, 12.462 hours/ns, 22.289 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    | 44.711     | 44.711     | 44.711     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021749   | 0.021749   | 0.021749   |   0.0 |  0.05
Output  | 5.2729e-05 | 5.2729e-05 | 5.2729e-05 |   0.0 |  0.00
Modify  | 0.1215     | 0.1215     | 0.1215     |   0.0 |  0.27
Other   |            | 0.0108     |            |       |  0.02

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

Total # of neighbors = 326894
Ave neighs/atom = 81.7235
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.507320231367, Press = 0.617001725095066
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -22757.862     -22757.862     -22922.014     -22922.014      317.56164      317.56164      60677.505      60677.505     -485.86182     -485.86182    
     38000  -22754.969     -22754.969     -22918.37      -22918.37       316.11139      316.11139      60710.75       60710.75      -1475.9172     -1475.9172    
Loop time of 44.8891 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.925 ns/day, 12.469 hours/ns, 22.277 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    | 44.735     | 44.735     | 44.735     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021772   | 0.021772   | 0.021772   |   0.0 |  0.05
Output  | 4.4303e-05 | 4.4303e-05 | 4.4303e-05 |   0.0 |  0.00
Modify  | 0.12173    | 0.12173    | 0.12173    |   0.0 |  0.27
Other   |            | 0.01082    |            |       |  0.02

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

Total # of neighbors = 327186
Ave neighs/atom = 81.7965
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.481218492959, Press = -0.0494702321268309
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -22754.969     -22754.969     -22918.37      -22918.37       316.11139      316.11139      60710.75       60710.75      -1475.9172     -1475.9172    
     39000  -22756.466     -22756.466     -22917.046     -22917.046      310.65416      310.65416      60665.601      60665.601      732.6111       732.6111     
Loop time of 44.8951 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.924 ns/day, 12.471 hours/ns, 22.274 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    | 44.741     | 44.741     | 44.741     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021842   | 0.021842   | 0.021842   |   0.0 |  0.05
Output  | 3.3313e-05 | 3.3313e-05 | 3.3313e-05 |   0.0 |  0.00
Modify  | 0.12163    | 0.12163    | 0.12163    |   0.0 |  0.27
Other   |            | 0.0108     |            |       |  0.02

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

Total # of neighbors = 326780
Ave neighs/atom = 81.695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.450387054994, Press = 2.74170513111487
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -22756.466     -22756.466     -22917.046     -22917.046      310.65416      310.65416      60665.601      60665.601      732.6111       732.6111     
     40000  -22758.518     -22758.518     -22921.269     -22921.269      314.85363      314.85363      60640.349      60640.349      1328.689       1328.689     
Loop time of 44.935 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.923 ns/day, 12.482 hours/ns, 22.254 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    | 44.781     | 44.781     | 44.781     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021868   | 0.021868   | 0.021868   |   0.0 |  0.05
Output  | 5.334e-05  | 5.334e-05  | 5.334e-05  |   0.0 |  0.00
Modify  | 0.12157    | 0.12157    | 0.12157    |   0.0 |  0.27
Other   |            | 0.01097    |            |       |  0.02

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

Total # of neighbors = 327066
Ave neighs/atom = 81.7665
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.43520163835, Press = -0.587106404472625
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -22758.518     -22758.518     -22921.269     -22921.269      314.85363      314.85363      60640.349      60640.349      1328.689       1328.689     
     41000  -22751.112     -22751.112     -22914.528     -22914.528      316.13806      316.13806      60691.905      60691.905     -54.353439     -54.353439    
Loop time of 44.9724 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.921 ns/day, 12.492 hours/ns, 22.236 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    | 44.818     | 44.818     | 44.818     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021657   | 0.021657   | 0.021657   |   0.0 |  0.05
Output  | 5.4111e-05 | 5.4111e-05 | 5.4111e-05 |   0.0 |  0.00
Modify  | 0.12134    | 0.12134    | 0.12134    |   0.0 |  0.27
Other   |            | 0.01084    |            |       |  0.02

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

Total # of neighbors = 327174
Ave neighs/atom = 81.7935
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.484046898957, Press = 0.530307148399228
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -22751.112     -22751.112     -22914.528     -22914.528      316.13806      316.13806      60691.905      60691.905     -54.353439     -54.353439    
     42000  -22758.84      -22758.84      -22920.233     -22920.233      312.22603      312.22603      60698.951      60698.951     -1282.8828     -1282.8828    
Loop time of 45.0019 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.920 ns/day, 12.501 hours/ns, 22.221 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    | 44.848     | 44.848     | 44.848     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021629   | 0.021629   | 0.021629   |   0.0 |  0.05
Output  | 4.5004e-05 | 4.5004e-05 | 4.5004e-05 |   0.0 |  0.00
Modify  | 0.12146    | 0.12146    | 0.12146    |   0.0 |  0.27
Other   |            | 0.01101    |            |       |  0.02

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

Total # of neighbors = 326882
Ave neighs/atom = 81.7205
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.50144330192, Press = 0.0742565158806706
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -22758.84      -22758.84      -22920.233     -22920.233      312.22603      312.22603      60698.951      60698.951     -1282.8828     -1282.8828    
     43000  -22755.134     -22755.134     -22917.404     -22917.404      313.92123      313.92123      60674.357      60674.357      256.51001      256.51001    
Loop time of 45.0802 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.917 ns/day, 12.522 hours/ns, 22.183 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    | 44.926     | 44.926     | 44.926     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021784   | 0.021784   | 0.021784   |   0.0 |  0.05
Output  | 3.6629e-05 | 3.6629e-05 | 3.6629e-05 |   0.0 |  0.00
Modify  | 0.12193    | 0.12193    | 0.12193    |   0.0 |  0.27
Other   |            | 0.01083    |            |       |  0.02

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

Total # of neighbors = 326824
Ave neighs/atom = 81.706
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.49642842477, Press = 2.16036878081338
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -22755.134     -22755.134     -22917.404     -22917.404      313.92123      313.92123      60674.357      60674.357      256.51001      256.51001    
     44000  -22759.012     -22759.012     -22918.258     -22918.258      308.07267      308.07267      60632.332      60632.332      2141.1601      2141.1601    
Loop time of 45.1889 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.912 ns/day, 12.552 hours/ns, 22.129 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    | 45.034     | 45.034     | 45.034     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022022   | 0.022022   | 0.022022   |   0.0 |  0.05
Output  | 5.9602e-05 | 5.9602e-05 | 5.9602e-05 |   0.0 |  0.00
Modify  | 0.12228    | 0.12228    | 0.12228    |   0.0 |  0.27
Other   |            | 0.01086    |            |       |  0.02

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

Total # of neighbors = 327168
Ave neighs/atom = 81.792
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.435214087075, Press = 1.04026768846085
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -22759.012     -22759.012     -22918.258     -22918.258      308.07267      308.07267      60632.332      60632.332      2141.1601      2141.1601    
     45000  -22758.476     -22758.476     -22919.675     -22919.675      311.84937      311.84937      60687.04       60687.04      -613.414       -613.414      
Loop time of 45.2641 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.909 ns/day, 12.573 hours/ns, 22.093 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    | 45.109     | 45.109     | 45.109     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021858   | 0.021858   | 0.021858   |   0.0 |  0.05
Output  | 8.51e-05   | 8.51e-05   | 8.51e-05   |   0.0 |  0.00
Modify  | 0.12217    | 0.12217    | 0.12217    |   0.0 |  0.27
Other   |            | 0.01087    |            |       |  0.02

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

Total # of neighbors = 327328
Ave neighs/atom = 81.832
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.440253998657, Press = -0.317207320868972
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -22758.476     -22758.476     -22919.675     -22919.675      311.84937      311.84937      60687.04       60687.04      -613.414       -613.414      
     46000  -22755.448     -22755.448     -22920.666     -22920.666      319.62586      319.62586      60648.345      60648.345      1118.1045      1118.1045    
Loop time of 45.1923 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.912 ns/day, 12.553 hours/ns, 22.128 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    | 45.037     | 45.037     | 45.037     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021933   | 0.021933   | 0.021933   |   0.0 |  0.05
Output  | 4.5255e-05 | 4.5255e-05 | 4.5255e-05 |   0.0 |  0.00
Modify  | 0.12215    | 0.12215    | 0.12215    |   0.0 |  0.27
Other   |            | 0.01086    |            |       |  0.02

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

Total # of neighbors = 326860
Ave neighs/atom = 81.715
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.446423537569, Press = 0.899646190322346
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -22755.448     -22755.448     -22920.666     -22920.666      319.62586      319.62586      60648.345      60648.345      1118.1045      1118.1045    
     47000  -22759.481     -22759.481     -22921.835     -22921.835      314.08571      314.08571      60720.175      60720.175     -2432.8954     -2432.8954    
Loop time of 45.1878 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.912 ns/day, 12.552 hours/ns, 22.130 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    | 45.033     | 45.033     | 45.033     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0219     | 0.0219     | 0.0219     |   0.0 |  0.05
Output  | 3.3823e-05 | 3.3823e-05 | 3.3823e-05 |   0.0 |  0.00
Modify  | 0.12213    | 0.12213    | 0.12213    |   0.0 |  0.27
Other   |            | 0.01083    |            |       |  0.02

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

Total # of neighbors = 327000
Ave neighs/atom = 81.75
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.443953913307, Press = 0.882963769162272
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -22759.481     -22759.481     -22921.835     -22921.835      314.08571      314.08571      60720.175      60720.175     -2432.8954     -2432.8954    
     48000  -22754.551     -22754.551     -22917.539     -22917.539      315.31188      315.31188      60628.506      60628.506      2306.4715      2306.4715    
Loop time of 45.0882 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.916 ns/day, 12.525 hours/ns, 22.179 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    | 44.933     | 44.933     | 44.933     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021874   | 0.021874   | 0.021874   |   0.0 |  0.05
Output  | 5.4372e-05 | 5.4372e-05 | 5.4372e-05 |   0.0 |  0.00
Modify  | 0.12207    | 0.12207    | 0.12207    |   0.0 |  0.27
Other   |            | 0.01088    |            |       |  0.02

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

Total # of neighbors = 326614
Ave neighs/atom = 81.6535
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.432459593179, Press = 0.87143394417912
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -22754.551     -22754.551     -22917.539     -22917.539      315.31188      315.31188      60628.506      60628.506      2306.4715      2306.4715    
     49000  -22757.284     -22757.284     -22919.235     -22919.235      313.3054       313.3054       60713.7        60713.7       -1789.333      -1789.333     
Loop time of 45.179 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.912 ns/day, 12.550 hours/ns, 22.134 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    | 45.024     | 45.024     | 45.024     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021883   | 0.021883   | 0.021883   |   0.0 |  0.05
Output  | 5.4062e-05 | 5.4062e-05 | 5.4062e-05 |   0.0 |  0.00
Modify  | 0.12224    | 0.12224    | 0.12224    |   0.0 |  0.27
Other   |            | 0.01088    |            |       |  0.02

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

Total # of neighbors = 327224
Ave neighs/atom = 81.806
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.393701760588, Press = 0.0623995034939594
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -22757.284     -22757.284     -22919.235     -22919.235      313.3054       313.3054       60713.7        60713.7       -1789.333      -1789.333     
     50000  -22751.547     -22751.547     -22914.702     -22914.702      315.63433      315.63433      60691.957      60691.957     -144.07564     -144.07564    
Loop time of 45.2667 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.909 ns/day, 12.574 hours/ns, 22.091 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    | 45.112     | 45.112     | 45.112     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021939   | 0.021939   | 0.021939   |   0.0 |  0.05
Output  | 4.4754e-05 | 4.4754e-05 | 4.4754e-05 |   0.0 |  0.00
Modify  | 0.12216    | 0.12216    | 0.12216    |   0.0 |  0.27
Other   |            | 0.01086    |            |       |  0.02

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

Total # of neighbors = 326728
Ave neighs/atom = 81.682
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.436742507383, Press = 0.914622438603886
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -22751.547     -22751.547     -22914.702     -22914.702      315.63433      315.63433      60691.957      60691.957     -144.07564     -144.07564    
     51000  -22755.031     -22755.031     -22920.559     -22920.559      320.22496      320.22496      60677.862      60677.862     -257.42152     -257.42152    
Loop time of 45.2123 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.911 ns/day, 12.559 hours/ns, 22.118 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    | 45.058     | 45.058     | 45.058     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021782   | 0.021782   | 0.021782   |   0.0 |  0.05
Output  | 3.3483e-05 | 3.3483e-05 | 3.3483e-05 |   0.0 |  0.00
Modify  | 0.12181    | 0.12181    | 0.12181    |   0.0 |  0.27
Other   |            | 0.01084    |            |       |  0.02

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

Total # of neighbors = 326764
Ave neighs/atom = 81.691
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.430460248712, Press = 0.309038397401327
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -22755.031     -22755.031     -22920.559     -22920.559      320.22496      320.22496      60677.862      60677.862     -257.42152     -257.42152    
     52000  -22758.778     -22758.778     -22918.271     -22918.271      308.55013      308.55013      60677.451      60677.451     -27.648538     -27.648538    
Loop time of 45.3198 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.906 ns/day, 12.589 hours/ns, 22.065 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    | 45.165     | 45.165     | 45.165     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022008   | 0.022008   | 0.022008   |   0.0 |  0.05
Output  | 5.2598e-05 | 5.2598e-05 | 5.2598e-05 |   0.0 |  0.00
Modify  | 0.12213    | 0.12213    | 0.12213    |   0.0 |  0.27
Other   |            | 0.01087    |            |       |  0.02

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

Total # of neighbors = 326970
Ave neighs/atom = 81.7425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.441099652072, Press = 1.15876438186631
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -22758.778     -22758.778     -22918.271     -22918.271      308.55013      308.55013      60677.451      60677.451     -27.648538     -27.648538    
     53000  -22754.208     -22754.208     -22916.373     -22916.373      313.71891      313.71891      60584.45       60584.45       4609.0719      4609.0719    
Loop time of 45.2407 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.910 ns/day, 12.567 hours/ns, 22.104 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    | 45.086     | 45.086     | 45.086     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021944   | 0.021944   | 0.021944   |   0.0 |  0.05
Output  | 5.323e-05  | 5.323e-05  | 5.323e-05  |   0.0 |  0.00
Modify  | 0.12228    | 0.12228    | 0.12228    |   0.0 |  0.27
Other   |            | 0.01089    |            |       |  0.02

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

Total # of neighbors = 326948
Ave neighs/atom = 81.737
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.45383348277, Press = -0.75371653435796
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -22754.208     -22754.208     -22916.373     -22916.373      313.71891      313.71891      60584.45       60584.45       4609.0719      4609.0719    
     54000  -22758.726     -22758.726     -22918.681     -22918.681      309.4439       309.4439       60696.608      60696.608     -1042.5238     -1042.5238    
Loop time of 45.2898 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.908 ns/day, 12.580 hours/ns, 22.080 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    | 45.135     | 45.135     | 45.135     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021755   | 0.021755   | 0.021755   |   0.0 |  0.05
Output  | 4.7309e-05 | 4.7309e-05 | 4.7309e-05 |   0.0 |  0.00
Modify  | 0.12232    | 0.12232    | 0.12232    |   0.0 |  0.27
Other   |            | 0.01086    |            |       |  0.02

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

Total # of neighbors = 327544
Ave neighs/atom = 81.886
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.465427833828, Press = 0.491507481966907
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -22758.726     -22758.726     -22918.681     -22918.681      309.4439       309.4439       60696.608      60696.608     -1042.5238     -1042.5238    
     55000  -22755.687     -22755.687     -22919.66      -22919.66       317.21794      317.21794      60692.224      60692.224     -889.90207     -889.90207    
Loop time of 45.1499 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.914 ns/day, 12.542 hours/ns, 22.148 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    | 44.995     | 44.995     | 44.995     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021922   | 0.021922   | 0.021922   |   0.0 |  0.05
Output  | 3.2521e-05 | 3.2521e-05 | 3.2521e-05 |   0.0 |  0.00
Modify  | 0.12221    | 0.12221    | 0.12221    |   0.0 |  0.27
Other   |            | 0.01088    |            |       |  0.02

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

Total # of neighbors = 326792
Ave neighs/atom = 81.698
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.460307708139, Press = 1.05864185141041
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -22755.687     -22755.687     -22919.66      -22919.66       317.21794      317.21794      60692.224      60692.224     -889.90207     -889.90207    
     56000  -22761.973     -22761.973     -22920.627     -22920.627      306.92765      306.92765      60671.479      60671.479     -100.29452     -100.29452    
Loop time of 45.0856 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.916 ns/day, 12.524 hours/ns, 22.180 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    | 44.931     | 44.931     | 44.931     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021803   | 0.021803   | 0.021803   |   0.0 |  0.05
Output  | 5.4302e-05 | 5.4302e-05 | 5.4302e-05 |   0.0 |  0.00
Modify  | 0.12228    | 0.12228    | 0.12228    |   0.0 |  0.27
Other   |            | 0.01087    |            |       |  0.02

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

Total # of neighbors = 326822
Ave neighs/atom = 81.7055
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.439616468868, Press = 0.631057644092763
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -22761.973     -22761.973     -22920.627     -22920.627      306.92765      306.92765      60671.479      60671.479     -100.29452     -100.29452    
     57000  -22759.852     -22759.852     -22918.265     -22918.265      306.4601       306.4601       60635.298      60635.298      1923.7824      1923.7824    
Loop time of 45.1368 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.914 ns/day, 12.538 hours/ns, 22.155 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    | 44.982     | 44.982     | 44.982     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021826   | 0.021826   | 0.021826   |   0.0 |  0.05
Output  | 5.5073e-05 | 5.5073e-05 | 5.5073e-05 |   0.0 |  0.00
Modify  | 0.12204    | 0.12204    | 0.12204    |   0.0 |  0.27
Other   |            | 0.01085    |            |       |  0.02

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

Total # of neighbors = 326784
Ave neighs/atom = 81.696
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.433143916662, Press = 0.733625869623628
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -22759.852     -22759.852     -22918.265     -22918.265      306.4601       306.4601       60635.298      60635.298      1923.7824      1923.7824    
     58000  -22753.249     -22753.249     -22916.166     -22916.166      315.17366      315.17366      60726.58       60726.58      -2054.0765     -2054.0765    
Loop time of 45.1976 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.912 ns/day, 12.555 hours/ns, 22.125 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    | 45.043     | 45.043     | 45.043     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021856   | 0.021856   | 0.021856   |   0.0 |  0.05
Output  | 5.7769e-05 | 5.7769e-05 | 5.7769e-05 |   0.0 |  0.00
Modify  | 0.12212    | 0.12212    | 0.12212    |   0.0 |  0.27
Other   |            | 0.01083    |            |       |  0.02

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

Total # of neighbors = 327116
Ave neighs/atom = 81.779
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.445396309454, Press = -0.606549218802817
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -22753.249     -22753.249     -22916.166     -22916.166      315.17366      315.17366      60726.58       60726.58      -2054.0765     -2054.0765    
     59000  -22756.891     -22756.891     -22919.434     -22919.434      314.45077      314.45077      60713.865      60713.865     -1910.9986     -1910.9986    
Loop time of 45.2264 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.910 ns/day, 12.563 hours/ns, 22.111 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    | 45.072     | 45.072     | 45.072     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02192    | 0.02192    | 0.02192    |   0.0 |  0.05
Output  | 3.2511e-05 | 3.2511e-05 | 3.2511e-05 |   0.0 |  0.00
Modify  | 0.1221     | 0.1221     | 0.1221     |   0.0 |  0.27
Other   |            | 0.01086    |            |       |  0.02

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

Total # of neighbors = 326710
Ave neighs/atom = 81.6775
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.433204611648, Press = 1.18555279104022
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -22756.891     -22756.891     -22919.434     -22919.434      314.45077      314.45077      60713.865      60713.865     -1910.9986     -1910.9986    
     60000  -22759.52      -22759.52      -22919.046     -22919.046      308.6125       308.6125       60706.75       60706.75      -1497.0644     -1497.0644    
Loop time of 45.2896 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.908 ns/day, 12.580 hours/ns, 22.080 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    | 45.135     | 45.135     | 45.135     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021876   | 0.021876   | 0.021876   |   0.0 |  0.05
Output  | 5.4913e-05 | 5.4913e-05 | 5.4913e-05 |   0.0 |  0.00
Modify  | 0.12217    | 0.12217    | 0.12217    |   0.0 |  0.27
Other   |            | 0.01092    |            |       |  0.02

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

Total # of neighbors = 326864
Ave neighs/atom = 81.716
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.443231668498, Press = 0.893262391330356
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -22759.52      -22759.52      -22919.046     -22919.046      308.6125       308.6125       60706.75       60706.75      -1497.0644     -1497.0644    
     61000  -22756.505     -22756.505     -22917.446     -22917.446      311.35065      311.35065      60724.424      60724.424     -2017.9892     -2017.9892    
Loop time of 45.2104 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.911 ns/day, 12.558 hours/ns, 22.119 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    | 45.055     | 45.055     | 45.055     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021896   | 0.021896   | 0.021896   |   0.0 |  0.05
Output  | 5.2929e-05 | 5.2929e-05 | 5.2929e-05 |   0.0 |  0.00
Modify  | 0.12224    | 0.12224    | 0.12224    |   0.0 |  0.27
Other   |            | 0.01085    |            |       |  0.02

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

Total # of neighbors = 326844
Ave neighs/atom = 81.711
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.454181022445, Press = 0.983655926265777
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -22756.505     -22756.505     -22917.446     -22917.446      311.35065      311.35065      60724.424      60724.424     -2017.9892     -2017.9892    
     62000  -22762.241     -22762.241     -22922.366     -22922.366      309.77329      309.77329      60644.609      60644.609      901.40245      901.40245    
Loop time of 45.2881 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.908 ns/day, 12.580 hours/ns, 22.081 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    | 45.133     | 45.133     | 45.133     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021851   | 0.021851   | 0.021851   |   0.0 |  0.05
Output  | 5.5174e-05 | 5.5174e-05 | 5.5174e-05 |   0.0 |  0.00
Modify  | 0.12216    | 0.12216    | 0.12216    |   0.0 |  0.27
Other   |            | 0.01085    |            |       |  0.02

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

Total # of neighbors = 326676
Ave neighs/atom = 81.669
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.452063060441, Press = 0.289610592839271
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -22762.241     -22762.241     -22922.366     -22922.366      309.77329      309.77329      60644.609      60644.609      901.40245      901.40245    
     63000  -22755.882     -22755.882     -22917.146     -22917.146      311.97483      311.97483      60738.237      60738.237     -2610.0128     -2610.0128    
Loop time of 45.1947 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.912 ns/day, 12.554 hours/ns, 22.126 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    | 45.04      | 45.04      | 45.04      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021765   | 0.021765   | 0.021765   |   0.0 |  0.05
Output  | 3.3473e-05 | 3.3473e-05 | 3.3473e-05 |   0.0 |  0.00
Modify  | 0.12173    | 0.12173    | 0.12173    |   0.0 |  0.27
Other   |            | 0.01083    |            |       |  0.02

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

Total # of neighbors = 327114
Ave neighs/atom = 81.7785
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.422479363287, Press = 0.0600275844822467
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -22755.882     -22755.882     -22917.146     -22917.146      311.97483      311.97483      60738.237      60738.237     -2610.0128     -2610.0128    
     64000  -22758.674     -22758.674     -22920.783     -22920.783      313.61053      313.61053      60654.597      60654.597      775.30259      775.30259    
Loop time of 45.2898 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.908 ns/day, 12.580 hours/ns, 22.080 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    | 45.135     | 45.135     | 45.135     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021862   | 0.021862   | 0.021862   |   0.0 |  0.05
Output  | 5.4322e-05 | 5.4322e-05 | 5.4322e-05 |   0.0 |  0.00
Modify  | 0.12227    | 0.12227    | 0.12227    |   0.0 |  0.27
Other   |            | 0.01092    |            |       |  0.02

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

Total # of neighbors = 326548
Ave neighs/atom = 81.637
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.411525069202, Press = 1.5895396315538
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -22758.674     -22758.674     -22920.783     -22920.783      313.61053      313.61053      60654.597      60654.597      775.30259      775.30259    
     65000  -22759.867     -22759.867     -22919.706     -22919.706      309.21938      309.21938      60681.752      60681.752     -356.70448     -356.70448    
Loop time of 45.2204 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.911 ns/day, 12.561 hours/ns, 22.114 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    | 45.066     | 45.066     | 45.066     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0218     | 0.0218     | 0.0218     |   0.0 |  0.05
Output  | 5.4953e-05 | 5.4953e-05 | 5.4953e-05 |   0.0 |  0.00
Modify  | 0.12196    | 0.12196    | 0.12196    |   0.0 |  0.27
Other   |            | 0.01087    |            |       |  0.02

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

Total # of neighbors = 327054
Ave neighs/atom = 81.7635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.42809832191, Press = 0.314343049635254
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -22759.867     -22759.867     -22919.706     -22919.706      309.21938      309.21938      60681.752      60681.752     -356.70448     -356.70448    
     66000  -22756.341     -22756.341     -22916.716     -22916.716      310.25559      310.25559      60674.101      60674.101      454.64044      454.64044    
Loop time of 45.1979 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.912 ns/day, 12.555 hours/ns, 22.125 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    | 45.043     | 45.043     | 45.043     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021977   | 0.021977   | 0.021977   |   0.0 |  0.05
Output  | 4.8802e-05 | 4.8802e-05 | 4.8802e-05 |   0.0 |  0.00
Modify  | 0.12189    | 0.12189    | 0.12189    |   0.0 |  0.27
Other   |            | 0.01082    |            |       |  0.02

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

Total # of neighbors = 326916
Ave neighs/atom = 81.729
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.442788989515, Press = 0.733133724256712
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -22756.341     -22756.341     -22916.716     -22916.716      310.25559      310.25559      60674.101      60674.101      454.64044      454.64044    
     67000  -22763.408     -22763.408     -22923.524     -22923.524      309.75602      309.75602      60667.049      60667.049     -178.15176     -178.15176    
Loop time of 45.1155 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.915 ns/day, 12.532 hours/ns, 22.165 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    | 44.961     | 44.961     | 44.961     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021855   | 0.021855   | 0.021855   |   0.0 |  0.05
Output  | 3.2371e-05 | 3.2371e-05 | 3.2371e-05 |   0.0 |  0.00
Modify  | 0.12196    | 0.12196    | 0.12196    |   0.0 |  0.27
Other   |            | 0.01082    |            |       |  0.02

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

Total # of neighbors = 327084
Ave neighs/atom = 81.771
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.426849989124, Press = 0.463068361172844
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -22763.408     -22763.408     -22923.524     -22923.524      309.75602      309.75602      60667.049      60667.049     -178.15176     -178.15176    
     68000  -22753.451     -22753.451     -22916.423     -22916.423      315.28014      315.28014      60652.396      60652.396      1497.0937      1497.0937    
Loop time of 45.1757 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.913 ns/day, 12.549 hours/ns, 22.136 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    | 45.021     | 45.021     | 45.021     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021808   | 0.021808   | 0.021808   |   0.0 |  0.05
Output  | 5.6136e-05 | 5.6136e-05 | 5.6136e-05 |   0.0 |  0.00
Modify  | 0.1219     | 0.1219     | 0.1219     |   0.0 |  0.27
Other   |            | 0.01084    |            |       |  0.02

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

Total # of neighbors = 326918
Ave neighs/atom = 81.7295
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.409968862796, Press = 1.38638829209463
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -22753.451     -22753.451     -22916.423     -22916.423      315.28014      315.28014      60652.396      60652.396      1497.0937      1497.0937    
     69000  -22756.041     -22756.041     -22921.182     -22921.182      319.47615      319.47615      60668.227      60668.227      227.01356      227.01356    
Loop time of 45.2771 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.908 ns/day, 12.577 hours/ns, 22.086 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    | 45.122     | 45.122     | 45.122     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021962   | 0.021962   | 0.021962   |   0.0 |  0.05
Output  | 5.4122e-05 | 5.4122e-05 | 5.4122e-05 |   0.0 |  0.00
Modify  | 0.12223    | 0.12223    | 0.12223    |   0.0 |  0.27
Other   |            | 0.01091    |            |       |  0.02

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

Total # of neighbors = 327070
Ave neighs/atom = 81.7675
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.420017798221, Press = -0.0314959442677513
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -22756.041     -22756.041     -22921.182     -22921.182      319.47615      319.47615      60668.227      60668.227      227.01356      227.01356    
     70000  -22759.961     -22759.961     -22918.957     -22918.957      307.58776      307.58776      60707.039      60707.039     -1472.4784     -1472.4784    
Loop time of 45.237 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.910 ns/day, 12.566 hours/ns, 22.106 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    | 45.082     | 45.082     | 45.082     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021827   | 0.021827   | 0.021827   |   0.0 |  0.05
Output  | 5.0885e-05 | 5.0885e-05 | 5.0885e-05 |   0.0 |  0.00
Modify  | 0.12193    | 0.12193    | 0.12193    |   0.0 |  0.27
Other   |            | 0.01087    |            |       |  0.02

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

Total # of neighbors = 327142
Ave neighs/atom = 81.7855
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.415217783038, Press = 0.464923832839895
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -22759.961     -22759.961     -22918.957     -22918.957      307.58776      307.58776      60707.039      60707.039     -1472.4784     -1472.4784    
     71000  -22754.895     -22754.895     -22918.545     -22918.545      316.59217      316.59217      60664.13       60664.13       618.1825       618.1825     
Loop time of 45.1631 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.913 ns/day, 12.545 hours/ns, 22.142 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    | 45.008     | 45.008     | 45.008     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021798   | 0.021798   | 0.021798   |   0.0 |  0.05
Output  | 3.3152e-05 | 3.3152e-05 | 3.3152e-05 |   0.0 |  0.00
Modify  | 0.12217    | 0.12217    | 0.12217    |   0.0 |  0.27
Other   |            | 0.01086    |            |       |  0.02

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

Total # of neighbors = 326704
Ave neighs/atom = 81.676
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.379749157419, Press = 0.58869313127539
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -22754.895     -22754.895     -22918.545     -22918.545      316.59217      316.59217      60664.13       60664.13       618.1825       618.1825     
     72000  -22761.808     -22761.808     -22921.005     -22921.005      307.97801      307.97801      60671.276      60671.276     -165.20075     -165.20075    
Loop time of 45.2683 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.909 ns/day, 12.575 hours/ns, 22.091 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    | 45.113     | 45.113     | 45.113     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022002   | 0.022002   | 0.022002   |   0.0 |  0.05
Output  | 5.4633e-05 | 5.4633e-05 | 5.4633e-05 |   0.0 |  0.00
Modify  | 0.12243    | 0.12243    | 0.12243    |   0.0 |  0.27
Other   |            | 0.01086    |            |       |  0.02

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

Total # of neighbors = 327162
Ave neighs/atom = 81.7905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.360192761545, Press = 0.299289757763136
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -22761.808     -22761.808     -22921.005     -22921.005      307.97801      307.97801      60671.276      60671.276     -165.20075     -165.20075    
     73000  -22756.486     -22756.486     -22917.078     -22917.078      310.6758       310.6758       60657.938      60657.938      965.58483      965.58483    
Loop time of 45.2547 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.909 ns/day, 12.571 hours/ns, 22.097 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    | 45.1       | 45.1       | 45.1       |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022105   | 0.022105   | 0.022105   |   0.0 |  0.05
Output  | 4.6457e-05 | 4.6457e-05 | 4.6457e-05 |   0.0 |  0.00
Modify  | 0.12219    | 0.12219    | 0.12219    |   0.0 |  0.27
Other   |            | 0.01083    |            |       |  0.02

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

Total # of neighbors = 327074
Ave neighs/atom = 81.7685
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.343652522155, Press = 0.60781718814142
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -22756.486     -22756.486     -22917.078     -22917.078      310.6758       310.6758       60657.938      60657.938      965.58483      965.58483    
     74000  -22765.656     -22765.656     -22924.239     -22924.239      306.78886      306.78886      60628.441      60628.441      1332.7705      1332.7705    
Loop time of 45.3148 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.907 ns/day, 12.587 hours/ns, 22.068 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    | 45.16      | 45.16      | 45.16      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02189    | 0.02189    | 0.02189    |   0.0 |  0.05
Output  | 4.288e-05  | 4.288e-05  | 4.288e-05  |   0.0 |  0.00
Modify  | 0.12215    | 0.12215    | 0.12215    |   0.0 |  0.27
Other   |            | 0.01084    |            |       |  0.02

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

Total # of neighbors = 327126
Ave neighs/atom = 81.7815
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.316109511817, Press = 0.403359949094966
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -22765.656     -22765.656     -22924.239     -22924.239      306.78886      306.78886      60628.441      60628.441      1332.7705      1332.7705    
     75000  -22755.53      -22755.53      -22918.359     -22918.359      315.00399      315.00399      60667.746      60667.746      383.14812      383.14812    
Loop time of 45.2614 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.909 ns/day, 12.573 hours/ns, 22.094 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    | 45.106     | 45.106     | 45.106     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021803   | 0.021803   | 0.021803   |   0.0 |  0.05
Output  | 2.8543e-05 | 2.8543e-05 | 2.8543e-05 |   0.0 |  0.00
Modify  | 0.12205    | 0.12205    | 0.12205    |   0.0 |  0.27
Other   |            | 0.01108    |            |       |  0.02

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

Total # of neighbors = 327252
Ave neighs/atom = 81.813
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.311863697752, Press = 0.718499919596018
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -22755.53      -22755.53      -22918.359     -22918.359      315.00399      315.00399      60667.746      60667.746      383.14812      383.14812    
     76000  -22756.476     -22756.476     -22916.236     -22916.236      309.06498      309.06498      60657.32       60657.32       1052.7887      1052.7887    
Loop time of 45.2875 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.908 ns/day, 12.580 hours/ns, 22.081 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    | 45.133     | 45.133     | 45.133     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021905   | 0.021905   | 0.021905   |   0.0 |  0.05
Output  | 7.5792e-05 | 7.5792e-05 | 7.5792e-05 |   0.0 |  0.00
Modify  | 0.1221     | 0.1221     | 0.1221     |   0.0 |  0.27
Other   |            | 0.01082    |            |       |  0.02

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

Total # of neighbors = 327206
Ave neighs/atom = 81.8015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.311496768776, Press = 0.862830004941364
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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -22756.476     -22756.476     -22916.236     -22916.236      309.06498      309.06498      60657.32       60657.32       1052.7887      1052.7887    
     77000  -22756.447     -22756.447     -22919.299     -22919.299      315.04836      315.04836      60654.824      60654.824      895.07971      895.07971    
Loop time of 45.2487 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.909 ns/day, 12.569 hours/ns, 22.100 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    | 45.094     | 45.094     | 45.094     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021886   | 0.021886   | 0.021886   |   0.0 |  0.05
Output  | 4.4013e-05 | 4.4013e-05 | 4.4013e-05 |   0.0 |  0.00
Modify  | 0.12167    | 0.12167    | 0.12167    |   0.0 |  0.27
Other   |            | 0.0108     |            |       |  0.02

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

Total # of neighbors = 327226
Ave neighs/atom = 81.8065
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
60675.8570572877

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0