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

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

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

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

kim_interactions Ag

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

kim interactions Ag
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_AcklandTichyVitek_1987_Ag__MO_212700056563_005
pair_coeff * * Ag
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 107.8682

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 68217.392307166 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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_212700056563_005#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 = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11738.92      -11738.92      -11869.776     -11869.776      253.15         253.15         68217.392      68217.392      2049.3803      2049.3803    
      1000  -11604.317     -11604.317     -11738.588     -11738.588      259.75749      259.75749      69656.193      69656.193     -713.63514     -713.63514    
Loop time of 5.2605 on 1 procs for 1000 steps with 4000 atoms

Performance: 16.424 ns/day, 1.461 hours/ns, 190.096 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    | 5.1097     | 5.1097     | 5.1097     |   0.0 | 97.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021434   | 0.021434   | 0.021434   |   0.0 |  0.41
Output  | 9.2815e-05 | 9.2815e-05 | 9.2815e-05 |   0.0 |  0.00
Modify  | 0.11886    | 0.11886    | 0.11886    |   0.0 |  2.26
Other   |            | 0.0104     |            |       |  0.20

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:       312000 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 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 = 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 = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11604.317     -11604.317     -11738.588     -11738.588      259.75749      259.75749      69656.193      69656.193     -713.63514     -713.63514    
      2000  -11616.502     -11616.502     -11746.587     -11746.587      251.65745      251.65745      69564.746      69564.746     -245.92395     -245.92395    
Loop time of 5.56019 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.539 ns/day, 1.544 hours/ns, 179.850 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    | 5.4094     | 5.4094     | 5.4094     |   0.0 | 97.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021898   | 0.021898   | 0.021898   |   0.0 |  0.39
Output  | 5.0565e-05 | 5.0565e-05 | 5.0565e-05 |   0.0 |  0.00
Modify  | 0.11848    | 0.11848    | 0.11848    |   0.0 |  2.13
Other   |            | 0.01041    |            |       |  0.19

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:       315884 ave      315884 max      315884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315884
Ave neighs/atom = 78.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11616.502     -11616.502     -11746.587     -11746.587      251.65745      251.65745      69564.746      69564.746     -245.92395     -245.92395    
      3000  -11611.548     -11611.548     -11741.627     -11741.627      251.64757      251.64757      69650.492      69650.492     -996.35087     -996.35087    
Loop time of 5.54651 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.577 ns/day, 1.541 hours/ns, 180.293 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    | 5.396      | 5.396      | 5.396      |   0.0 | 97.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021646   | 0.021646   | 0.021646   |   0.0 |  0.39
Output  | 4.3612e-05 | 4.3612e-05 | 4.3612e-05 |   0.0 |  0.00
Modify  | 0.1184     | 0.1184     | 0.1184     |   0.0 |  2.13
Other   |            | 0.01038    |            |       |  0.19

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:       315910 ave      315910 max      315910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315910
Ave neighs/atom = 78.9775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11611.548     -11611.548     -11741.627     -11741.627      251.64757      251.64757      69650.492      69650.492     -996.35087     -996.35087    
      4000  -11614.511     -11614.511     -11744.277     -11744.277      251.04164      251.04164      69502.4        69502.4        1254.6464      1254.6464    
Loop time of 5.55361 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.557 ns/day, 1.543 hours/ns, 180.063 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.4035     | 5.4035     | 5.4035     |   0.0 | 97.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021543   | 0.021543   | 0.021543   |   0.0 |  0.39
Output  | 3.5696e-05 | 3.5696e-05 | 3.5696e-05 |   0.0 |  0.00
Modify  | 0.11813    | 0.11813    | 0.11813    |   0.0 |  2.13
Other   |            | 0.01039    |            |       |  0.19

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:       315810 ave      315810 max      315810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315810
Ave neighs/atom = 78.9525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11614.511     -11614.511     -11744.277     -11744.277      251.04164      251.04164      69502.4        69502.4        1254.6464      1254.6464    
      5000  -11615.136     -11615.136     -11742.979     -11742.979      247.32001      247.32001      69606.603      69606.603     -568.1561      -568.1561     
Loop time of 5.54833 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.572 ns/day, 1.541 hours/ns, 180.234 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    | 5.3981     | 5.3981     | 5.3981     |   0.0 | 97.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021615   | 0.021615   | 0.021615   |   0.0 |  0.39
Output  | 3.8212e-05 | 3.8212e-05 | 3.8212e-05 |   0.0 |  0.00
Modify  | 0.1182     | 0.1182     | 0.1182     |   0.0 |  2.13
Other   |            | 0.01034    |            |       |  0.19

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:       316130 ave      316130 max      316130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316130
Ave neighs/atom = 79.0325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 254.937739432426, Press = 297.727961276865
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11615.136     -11615.136     -11742.979     -11742.979      247.32001      247.32001      69606.603      69606.603     -568.1561      -568.1561     
      6000  -11611.498     -11611.498     -11743.599     -11743.599      255.55872      255.55872      69471.37       69471.37       1910.2596      1910.2596    
Loop time of 5.55879 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.543 ns/day, 1.544 hours/ns, 179.895 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    | 5.4051     | 5.4051     | 5.4051     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021593   | 0.021593   | 0.021593   |   0.0 |  0.39
Output  | 3.738e-05  | 3.738e-05  | 3.738e-05  |   0.0 |  0.00
Modify  | 0.1217     | 0.1217     | 0.1217     |   0.0 |  2.19
Other   |            | 0.01035    |            |       |  0.19

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:       315866 ave      315866 max      315866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315866
Ave neighs/atom = 78.9665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.813132488334, Press = 24.5373878980885
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11611.498     -11611.498     -11743.599     -11743.599      255.55872      255.55872      69471.37       69471.37       1910.2596      1910.2596    
      7000  -11613.918     -11613.918     -11743.383     -11743.383      250.4592       250.4592       69493.913      69493.913      1444.0965      1444.0965    
Loop time of 5.55856 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.544 ns/day, 1.544 hours/ns, 179.903 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.405      | 5.405      | 5.405      |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021696   | 0.021696   | 0.021696   |   0.0 |  0.39
Output  | 6.6305e-05 | 6.6305e-05 | 6.6305e-05 |   0.0 |  0.00
Modify  | 0.12154    | 0.12154    | 0.12154    |   0.0 |  2.19
Other   |            | 0.01026    |            |       |  0.18

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:       316160 ave      316160 max      316160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316160
Ave neighs/atom = 79.04
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.040810821864, Press = 1.07750279098875
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11613.918     -11613.918     -11743.383     -11743.383      250.4592       250.4592       69493.913      69493.913      1444.0965      1444.0965    
      8000  -11611.672     -11611.672     -11742.258     -11742.258      252.62612      252.62612      69589.229      69589.229     -92.479033     -92.479033    
Loop time of 5.55248 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.561 ns/day, 1.542 hours/ns, 180.100 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.3993     | 5.3993     | 5.3993     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021452   | 0.021452   | 0.021452   |   0.0 |  0.39
Output  | 3.1018e-05 | 3.1018e-05 | 3.1018e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  2.19
Other   |            | 0.01033    |            |       |  0.19

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:       316208 ave      316208 max      316208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316208
Ave neighs/atom = 79.052
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.247930305983, Press = 12.3398663132686
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11611.672     -11611.672     -11742.258     -11742.258      252.62612      252.62612      69589.229      69589.229     -92.479033     -92.479033    
      9000  -11616.873     -11616.873     -11747.268     -11747.268      252.25809      252.25809      69569.822      69569.822     -456.46286     -456.46286    
Loop time of 5.55832 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.544 ns/day, 1.544 hours/ns, 179.910 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.4051     | 5.4051     | 5.4051     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02157    | 0.02157    | 0.02157    |   0.0 |  0.39
Output  | 3.0698e-05 | 3.0698e-05 | 3.0698e-05 |   0.0 |  0.00
Modify  | 0.12132    | 0.12132    | 0.12132    |   0.0 |  2.18
Other   |            | 0.01034    |            |       |  0.19

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:       315892 ave      315892 max      315892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315892
Ave neighs/atom = 78.973
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.170146368419, Press = 5.17519903353521
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11616.873     -11616.873     -11747.268     -11747.268      252.25809      252.25809      69569.822      69569.822     -456.46286     -456.46286    
     10000  -11611.311     -11611.311     -11744.407     -11744.407      257.48358      257.48358      69481.701      69481.701      1654.8054      1654.8054    
Loop time of 5.54148 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.591 ns/day, 1.539 hours/ns, 180.457 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.3882     | 5.3882     | 5.3882     |   0.0 | 97.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021475   | 0.021475   | 0.021475   |   0.0 |  0.39
Output  | 3.1229e-05 | 3.1229e-05 | 3.1229e-05 |   0.0 |  0.00
Modify  | 0.12146    | 0.12146    | 0.12146    |   0.0 |  2.19
Other   |            | 0.01035    |            |       |  0.19

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:       315820 ave      315820 max      315820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315820
Ave neighs/atom = 78.955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.064307305838, Press = 5.5329678734113
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11611.311     -11611.311     -11744.407     -11744.407      257.48358      257.48358      69481.701      69481.701      1654.8054      1654.8054    
     11000  -11616.467     -11616.467     -11746.617     -11746.617      251.7827       251.7827       69534.138      69534.138      314.1652       314.1652     
Loop time of 5.55184 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.562 ns/day, 1.542 hours/ns, 180.120 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.3984     | 5.3984     | 5.3984     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021558   | 0.021558   | 0.021558   |   0.0 |  0.39
Output  | 2.8894e-05 | 2.8894e-05 | 2.8894e-05 |   0.0 |  0.00
Modify  | 0.12152    | 0.12152    | 0.12152    |   0.0 |  2.19
Other   |            | 0.01037    |            |       |  0.19

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:       316134 ave      316134 max      316134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316134
Ave neighs/atom = 79.0335
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.916825781344, Press = 1.54341146136157
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11616.467     -11616.467     -11746.617     -11746.617      251.7827       251.7827       69534.138      69534.138      314.1652       314.1652     
     12000  -11613.515     -11613.515     -11744.195     -11744.195      252.81025      252.81025      69565.509      69565.509      28.498576      28.498576    
Loop time of 5.57966 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.485 ns/day, 1.550 hours/ns, 179.222 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.426      | 5.426      | 5.426      |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021559   | 0.021559   | 0.021559   |   0.0 |  0.39
Output  | 3.3613e-05 | 3.3613e-05 | 3.3613e-05 |   0.0 |  0.00
Modify  | 0.12163    | 0.12163    | 0.12163    |   0.0 |  2.18
Other   |            | 0.01039    |            |       |  0.19

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:       316036 ave      316036 max      316036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316036
Ave neighs/atom = 79.009
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.881548675064, Press = 0.479996918498963
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11613.515     -11613.515     -11744.195     -11744.195      252.81025      252.81025      69565.509      69565.509      28.498576      28.498576    
     13000  -11614.473     -11614.473     -11745.264     -11745.264      253.02438      253.02438      69574.224      69574.224     -273.36841     -273.36841    
Loop time of 5.56275 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.532 ns/day, 1.545 hours/ns, 179.767 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.4091     | 5.4091     | 5.4091     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021694   | 0.021694   | 0.021694   |   0.0 |  0.39
Output  | 3.0237e-05 | 3.0237e-05 | 3.0237e-05 |   0.0 |  0.00
Modify  | 0.12157    | 0.12157    | 0.12157    |   0.0 |  2.19
Other   |            | 0.01037    |            |       |  0.19

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:       315870 ave      315870 max      315870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315870
Ave neighs/atom = 78.9675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.863535616605, Press = 3.32578115310304
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11614.473     -11614.473     -11745.264     -11745.264      253.02438      253.02438      69574.224      69574.224     -273.36841     -273.36841    
     14000  -11613.146     -11613.146     -11742.138     -11742.138      249.54429      249.54429      69622.202      69622.202     -733.93906     -733.93906    
Loop time of 5.57088 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.509 ns/day, 1.547 hours/ns, 179.505 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.4174     | 5.4174     | 5.4174     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021564   | 0.021564   | 0.021564   |   0.0 |  0.39
Output  | 3.177e-05  | 3.177e-05  | 3.177e-05  |   0.0 |  0.00
Modify  | 0.12155    | 0.12155    | 0.12155    |   0.0 |  2.18
Other   |            | 0.01037    |            |       |  0.19

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:       315956 ave      315956 max      315956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315956
Ave neighs/atom = 78.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.903107448238, Press = 4.29439486015063
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11613.146     -11613.146     -11742.138     -11742.138      249.54429      249.54429      69622.202      69622.202     -733.93906     -733.93906    
     15000  -11616.895     -11616.895     -11745.194     -11745.194      248.20396      248.20396      69583.348      69583.348     -457.28943     -457.28943    
Loop time of 5.57257 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.505 ns/day, 1.548 hours/ns, 179.450 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.4191     | 5.4191     | 5.4191     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021645   | 0.021645   | 0.021645   |   0.0 |  0.39
Output  | 2.9455e-05 | 2.9455e-05 | 2.9455e-05 |   0.0 |  0.00
Modify  | 0.12145    | 0.12145    | 0.12145    |   0.0 |  2.18
Other   |            | 0.01038    |            |       |  0.19

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:       315846 ave      315846 max      315846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315846
Ave neighs/atom = 78.9615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.811808505592, Press = 1.65468020079233
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11616.895     -11616.895     -11745.194     -11745.194      248.20396      248.20396      69583.348      69583.348     -457.28943     -457.28943    
     16000  -11612.164     -11612.164     -11743.322     -11743.322      253.73404      253.73404      69580.362      69580.362     -35.060402     -35.060402    
Loop time of 5.57342 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.502 ns/day, 1.548 hours/ns, 179.423 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.42       | 5.42       | 5.42       |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021421   | 0.021421   | 0.021421   |   0.0 |  0.38
Output  | 3.2652e-05 | 3.2652e-05 | 3.2652e-05 |   0.0 |  0.00
Modify  | 0.12154    | 0.12154    | 0.12154    |   0.0 |  2.18
Other   |            | 0.01038    |            |       |  0.19

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:       315830 ave      315830 max      315830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315830
Ave neighs/atom = 78.9575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.748020755986, Press = 0.609623609292353
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11612.164     -11612.164     -11743.322     -11743.322      253.73404      253.73404      69580.362      69580.362     -35.060402     -35.060402    
     17000  -11612.522     -11612.522     -11742.738     -11742.738      251.91035      251.91035      69567.909      69567.909      173.67968      173.67968    
Loop time of 5.57421 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.500 ns/day, 1.548 hours/ns, 179.398 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.4207     | 5.4207     | 5.4207     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021601   | 0.021601   | 0.021601   |   0.0 |  0.39
Output  | 3.3333e-05 | 3.3333e-05 | 3.3333e-05 |   0.0 |  0.00
Modify  | 0.12151    | 0.12151    | 0.12151    |   0.0 |  2.18
Other   |            | 0.01038    |            |       |  0.19

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:       316116 ave      316116 max      316116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316116
Ave neighs/atom = 79.029
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.737568037153, Press = 3.55758648499625
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11612.522     -11612.522     -11742.738     -11742.738      251.91035      251.91035      69567.909      69567.909      173.67968      173.67968    
     18000  -11615.878     -11615.878     -11746.546     -11746.546      252.78562      252.78562      69561.7        69561.7       -260.24291     -260.24291    
Loop time of 5.57351 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.502 ns/day, 1.548 hours/ns, 179.420 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.4199     | 5.4199     | 5.4199     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021594   | 0.021594   | 0.021594   |   0.0 |  0.39
Output  | 4.0446e-05 | 4.0446e-05 | 4.0446e-05 |   0.0 |  0.00
Modify  | 0.12154    | 0.12154    | 0.12154    |   0.0 |  2.18
Other   |            | 0.01039    |            |       |  0.19

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:       315914 ave      315914 max      315914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315914
Ave neighs/atom = 78.9785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.768753492727, Press = 2.05799808523537
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11615.878     -11615.878     -11746.546     -11746.546      252.78562      252.78562      69561.7        69561.7       -260.24291     -260.24291    
     19000  -11610.367     -11610.367     -11744.874     -11744.874      260.21315      260.21315      69609.952      69609.952     -796.82064     -796.82064    
Loop time of 5.55407 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.556 ns/day, 1.543 hours/ns, 180.048 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.4007     | 5.4007     | 5.4007     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021535   | 0.021535   | 0.021535   |   0.0 |  0.39
Output  | 2.9365e-05 | 2.9365e-05 | 2.9365e-05 |   0.0 |  0.00
Modify  | 0.12138    | 0.12138    | 0.12138    |   0.0 |  2.19
Other   |            | 0.01039    |            |       |  0.19

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:       315976 ave      315976 max      315976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315976
Ave neighs/atom = 78.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.720912223329, Press = 0.320337913103455
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11610.367     -11610.367     -11744.874     -11744.874      260.21315      260.21315      69609.952      69609.952     -796.82064     -796.82064    
     20000  -11612.912     -11612.912     -11744.205     -11744.205      253.99594      253.99594      69640.963      69640.963     -1263.9037     -1263.9037    
Loop time of 5.54783 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.574 ns/day, 1.541 hours/ns, 180.251 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    | 5.3947     | 5.3947     | 5.3947     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021604   | 0.021604   | 0.021604   |   0.0 |  0.39
Output  | 3.202e-05  | 3.202e-05  | 3.202e-05  |   0.0 |  0.00
Modify  | 0.12118    | 0.12118    | 0.12118    |   0.0 |  2.18
Other   |            | 0.01033    |            |       |  0.19

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:       315912 ave      315912 max      315912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315912
Ave neighs/atom = 78.978
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.767590746976, Press = 0.515138605160643
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11612.912     -11612.912     -11744.205     -11744.205      253.99594      253.99594      69640.963      69640.963     -1263.9037     -1263.9037    
     21000  -11613.129     -11613.129     -11744.076     -11744.076      253.32639      253.32639      69583.569      69583.569     -292.64933     -292.64933    
Loop time of 5.5654 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.524 ns/day, 1.546 hours/ns, 179.682 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    | 5.4125     | 5.4125     | 5.4125     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02147    | 0.02147    | 0.02147    |   0.0 |  0.39
Output  | 3.2151e-05 | 3.2151e-05 | 3.2151e-05 |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  2.18
Other   |            | 0.01029    |            |       |  0.18

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:       315732 ave      315732 max      315732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315732
Ave neighs/atom = 78.933
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.873715775183, Press = 1.54210937806805
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11613.129     -11613.129     -11744.076     -11744.076      253.32639      253.32639      69583.569      69583.569     -292.64933     -292.64933    
     22000  -11612.431     -11612.431     -11744.247     -11744.247      255.00726      255.00726      69558.045      69558.045      181.05178      181.05178    
Loop time of 5.56632 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.522 ns/day, 1.546 hours/ns, 179.652 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.4128     | 5.4128     | 5.4128     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021819   | 0.021819   | 0.021819   |   0.0 |  0.39
Output  | 3.0798e-05 | 3.0798e-05 | 3.0798e-05 |   0.0 |  0.00
Modify  | 0.12137    | 0.12137    | 0.12137    |   0.0 |  2.18
Other   |            | 0.01034    |            |       |  0.19

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:       316004 ave      316004 max      316004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316004
Ave neighs/atom = 79.001
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.836736654389, Press = 2.45200077668033
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11612.431     -11612.431     -11744.247     -11744.247      255.00726      255.00726      69558.045      69558.045      181.05178      181.05178    
     23000  -11611.231     -11611.231     -11743.157     -11743.157      255.21965      255.21965      69635.443      69635.443     -987.19865     -987.19865    
Loop time of 5.5653 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.525 ns/day, 1.546 hours/ns, 179.685 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.412      | 5.412      | 5.412      |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021639   | 0.021639   | 0.021639   |   0.0 |  0.39
Output  | 3.159e-05  | 3.159e-05  | 3.159e-05  |   0.0 |  0.00
Modify  | 0.12133    | 0.12133    | 0.12133    |   0.0 |  2.18
Other   |            | 0.01032    |            |       |  0.19

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:       316056 ave      316056 max      316056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316056
Ave neighs/atom = 79.014
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.928971283899, Press = 2.42430789969469
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11611.231     -11611.231     -11743.157     -11743.157      255.21965      255.21965      69635.443      69635.443     -987.19865     -987.19865    
     24000  -11613.483     -11613.483     -11745.308     -11745.308      255.02308      255.02308      69554.523      69554.523      103.32499      103.32499    
Loop time of 5.57893 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.487 ns/day, 1.550 hours/ns, 179.246 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    | 5.4261     | 5.4261     | 5.4261     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021599   | 0.021599   | 0.021599   |   0.0 |  0.39
Output  | 7.8488e-05 | 7.8488e-05 | 7.8488e-05 |   0.0 |  0.00
Modify  | 0.12088    | 0.12088    | 0.12088    |   0.0 |  2.17
Other   |            | 0.01025    |            |       |  0.18

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:       315952 ave      315952 max      315952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315952
Ave neighs/atom = 78.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.93962653625, Press = 3.44192365217209
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11613.483     -11613.483     -11745.308     -11745.308      255.02308      255.02308      69554.523      69554.523      103.32499      103.32499    
     25000  -11615.006     -11615.006     -11744.57      -11744.57       250.65074      250.65074      69580.286      69580.286     -282.95604     -282.95604    
Loop time of 5.56071 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.538 ns/day, 1.545 hours/ns, 179.833 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    | 5.4081     | 5.4081     | 5.4081     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021532   | 0.021532   | 0.021532   |   0.0 |  0.39
Output  | 3.1339e-05 | 3.1339e-05 | 3.1339e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  2.17
Other   |            | 0.01024    |            |       |  0.18

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:       316066 ave      316066 max      316066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316066
Ave neighs/atom = 79.0165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.949925778442, Press = 0.740044325058563
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11615.006     -11615.006     -11744.57      -11744.57       250.65074      250.65074      69580.286      69580.286     -282.95604     -282.95604    
     26000  -11610.633     -11610.633     -11743.95      -11743.95       257.91067      257.91067      69611.855      69611.855     -716.41025     -716.41025    
Loop time of 5.57348 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.502 ns/day, 1.548 hours/ns, 179.421 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    | 5.4208     | 5.4208     | 5.4208     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021549   | 0.021549   | 0.021549   |   0.0 |  0.39
Output  | 3.0988e-05 | 3.0988e-05 | 3.0988e-05 |   0.0 |  0.00
Modify  | 0.12086    | 0.12086    | 0.12086    |   0.0 |  2.17
Other   |            | 0.01027    |            |       |  0.18

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:       315906 ave      315906 max      315906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315906
Ave neighs/atom = 78.9765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.89404938925, Press = 2.05546460561267
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11610.633     -11610.633     -11743.95      -11743.95       257.91067      257.91067      69611.855      69611.855     -716.41025     -716.41025    
     27000  -11615.822     -11615.822     -11744.869     -11744.869      249.6511       249.6511       69508.501      69508.501      935.85174      935.85174    
Loop time of 5.58537 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.469 ns/day, 1.551 hours/ns, 179.039 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    | 5.4324     | 5.4324     | 5.4324     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02161    | 0.02161    | 0.02161    |   0.0 |  0.39
Output  | 3.191e-05  | 3.191e-05  | 3.191e-05  |   0.0 |  0.00
Modify  | 0.1211     | 0.1211     | 0.1211     |   0.0 |  2.17
Other   |            | 0.01026    |            |       |  0.18

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:       315838 ave      315838 max      315838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315838
Ave neighs/atom = 78.9595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.896569118557, Press = 2.68204227277562
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11615.822     -11615.822     -11744.869     -11744.869      249.6511       249.6511       69508.501      69508.501      935.85174      935.85174    
     28000  -11612.175     -11612.175     -11742.45      -11742.45       252.02677      252.02677      69608.432      69608.432     -464.61234     -464.61234    
Loop time of 5.58946 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.458 ns/day, 1.553 hours/ns, 178.908 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    | 5.4364     | 5.4364     | 5.4364     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021437   | 0.021437   | 0.021437   |   0.0 |  0.38
Output  | 3.8102e-05 | 3.8102e-05 | 3.8102e-05 |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  2.17
Other   |            | 0.01031    |            |       |  0.18

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:       316070 ave      316070 max      316070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316070
Ave neighs/atom = 79.0175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.885930233524, Press = 0.72807984846966
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11612.175     -11612.175     -11742.45      -11742.45       252.02677      252.02677      69608.432      69608.432     -464.61234     -464.61234    
     29000  -11616.315     -11616.315     -11747.011     -11747.011      252.8393       252.8393       69550.099      69550.099     -98.721393     -98.721393    
Loop time of 5.57885 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.487 ns/day, 1.550 hours/ns, 179.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    | 5.4254     | 5.4254     | 5.4254     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021539   | 0.021539   | 0.021539   |   0.0 |  0.39
Output  | 3.0137e-05 | 3.0137e-05 | 3.0137e-05 |   0.0 |  0.00
Modify  | 0.1215     | 0.1215     | 0.1215     |   0.0 |  2.18
Other   |            | 0.01033    |            |       |  0.19

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:       315934 ave      315934 max      315934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315934
Ave neighs/atom = 78.9835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.816757276435, Press = 1.19565836991487
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11616.315     -11616.315     -11747.011     -11747.011      252.8393       252.8393       69550.099      69550.099     -98.721393     -98.721393    
     30000  -11610.584     -11610.584     -11741.909     -11741.909      254.05778      254.05778      69601.884      69601.884     -225.67669     -225.67669    
Loop time of 5.55531 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.553 ns/day, 1.543 hours/ns, 180.008 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    | 5.402      | 5.402      | 5.402      |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021426   | 0.021426   | 0.021426   |   0.0 |  0.39
Output  | 3.149e-05  | 3.149e-05  | 3.149e-05  |   0.0 |  0.00
Modify  | 0.12151    | 0.12151    | 0.12151    |   0.0 |  2.19
Other   |            | 0.01039    |            |       |  0.19

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:       315848 ave      315848 max      315848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315848
Ave neighs/atom = 78.962
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.812004443981, Press = 1.27340709818472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11610.584     -11610.584     -11741.909     -11741.909      254.05778      254.05778      69601.884      69601.884     -225.67669     -225.67669    
     31000  -11613.711     -11613.711     -11743.998     -11743.998      252.04916      252.04916      69492.832      69492.832      1454.3647      1454.3647    
Loop time of 5.59155 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.452 ns/day, 1.553 hours/ns, 178.841 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    | 5.4381     | 5.4381     | 5.4381     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021586   | 0.021586   | 0.021586   |   0.0 |  0.39
Output  | 2.9856e-05 | 2.9856e-05 | 2.9856e-05 |   0.0 |  0.00
Modify  | 0.1215     | 0.1215     | 0.1215     |   0.0 |  2.17
Other   |            | 0.01034    |            |       |  0.18

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:       315872 ave      315872 max      315872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315872
Ave neighs/atom = 78.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.838425456422, Press = 1.66693137222758
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11613.711     -11613.711     -11743.998     -11743.998      252.04916      252.04916      69492.832      69492.832      1454.3647      1454.3647    
     32000  -11614.984     -11614.984     -11745.343     -11745.343      252.1885       252.1885       69494.101      69494.101      1206.4373      1206.4373    
Loop time of 5.57407 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.500 ns/day, 1.548 hours/ns, 179.402 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    | 5.4208     | 5.4208     | 5.4208     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021539   | 0.021539   | 0.021539   |   0.0 |  0.39
Output  | 3.4264e-05 | 3.4264e-05 | 3.4264e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  2.18
Other   |            | 0.01034    |            |       |  0.19

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:       316166 ave      316166 max      316166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316166
Ave neighs/atom = 79.0415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.856928817642, Press = -0.107484730436123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11614.984     -11614.984     -11745.343     -11745.343      252.1885       252.1885       69494.101      69494.101      1206.4373      1206.4373    
     33000  -11610.943     -11610.943     -11743.488     -11743.488      256.41761      256.41761      69571.978      69571.978      37.896809      37.896809    
Loop time of 5.56409 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.528 ns/day, 1.546 hours/ns, 179.724 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    | 5.411      | 5.411      | 5.411      |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021549   | 0.021549   | 0.021549   |   0.0 |  0.39
Output  | 3.1168e-05 | 3.1168e-05 | 3.1168e-05 |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  2.18
Other   |            | 0.01031    |            |       |  0.19

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:       315934 ave      315934 max      315934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315934
Ave neighs/atom = 78.9835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.834626501792, Press = -0.488054217074863
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11610.943     -11610.943     -11743.488     -11743.488      256.41761      256.41761      69571.978      69571.978      37.896809      37.896809    
     34000  -11614.653     -11614.653     -11744.514     -11744.514      251.22501      251.22501      69632.857      69632.857     -1236.5938     -1236.5938    
Loop time of 5.56148 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.535 ns/day, 1.545 hours/ns, 179.808 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    | 5.4087     | 5.4087     | 5.4087     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021496   | 0.021496   | 0.021496   |   0.0 |  0.39
Output  | 2.8854e-05 | 2.8854e-05 | 2.8854e-05 |   0.0 |  0.00
Modify  | 0.12093    | 0.12093    | 0.12093    |   0.0 |  2.17
Other   |            | 0.01032    |            |       |  0.19

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:       315894 ave      315894 max      315894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315894
Ave neighs/atom = 78.9735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.868352985587, Press = -0.496029461852224
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11614.653     -11614.653     -11744.514     -11744.514      251.22501      251.22501      69632.857      69632.857     -1236.5938     -1236.5938    
     35000  -11615.341     -11615.341     -11744.579     -11744.579      250.02049      250.02049      69579.46       69579.46      -341.70157     -341.70157    
Loop time of 5.58198 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.478 ns/day, 1.551 hours/ns, 179.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    | 5.4291     | 5.4291     | 5.4291     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021558   | 0.021558   | 0.021558   |   0.0 |  0.39
Output  | 3.3844e-05 | 3.3844e-05 | 3.3844e-05 |   0.0 |  0.00
Modify  | 0.12096    | 0.12096    | 0.12096    |   0.0 |  2.17
Other   |            | 0.01031    |            |       |  0.18

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:       315816 ave      315816 max      315816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315816
Ave neighs/atom = 78.954
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.901942720877, Press = 1.34345749312676
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11615.341     -11615.341     -11744.579     -11744.579      250.02049      250.02049      69579.46       69579.46      -341.70157     -341.70157    
     36000  -11609.767     -11609.767     -11744.036     -11744.036      259.75284      259.75284      69582.899      69582.899     -236.80364     -236.80364    
Loop time of 5.57174 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.507 ns/day, 1.548 hours/ns, 179.477 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    | 5.419      | 5.419      | 5.419      |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021504   | 0.021504   | 0.021504   |   0.0 |  0.39
Output  | 3.2101e-05 | 3.2101e-05 | 3.2101e-05 |   0.0 |  0.00
Modify  | 0.12089    | 0.12089    | 0.12089    |   0.0 |  2.17
Other   |            | 0.01033    |            |       |  0.19

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:       315880 ave      315880 max      315880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315880
Ave neighs/atom = 78.97
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.910201477984, Press = 0.538756683266797
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11609.767     -11609.767     -11744.036     -11744.036      259.75284      259.75284      69582.899      69582.899     -236.80364     -236.80364    
     37000  -11613.13      -11613.13      -11744.781     -11744.781      254.68762      254.68762      69606.267      69606.267     -815.23113     -815.23113    
Loop time of 5.57785 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.490 ns/day, 1.549 hours/ns, 179.281 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    | 5.4248     | 5.4248     | 5.4248     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021605   | 0.021605   | 0.021605   |   0.0 |  0.39
Output  | 3.0467e-05 | 3.0467e-05 | 3.0467e-05 |   0.0 |  0.00
Modify  | 0.12111    | 0.12111    | 0.12111    |   0.0 |  2.17
Other   |            | 0.01031    |            |       |  0.18

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:       315974 ave      315974 max      315974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315974
Ave neighs/atom = 78.9935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.980640693313, Press = 0.487548656581286
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11613.13      -11613.13      -11744.781     -11744.781      254.68762      254.68762      69606.267      69606.267     -815.23113     -815.23113    
     38000  -11612.177     -11612.177     -11742.124     -11742.124      251.39244      251.39244      69581.74       69581.74       44.292429      44.292429    
Loop time of 5.58989 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.456 ns/day, 1.553 hours/ns, 178.894 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    | 5.4365     | 5.4365     | 5.4365     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02149    | 0.02149    | 0.02149    |   0.0 |  0.38
Output  | 3.0457e-05 | 3.0457e-05 | 3.0457e-05 |   0.0 |  0.00
Modify  | 0.12147    | 0.12147    | 0.12147    |   0.0 |  2.17
Other   |            | 0.01035    |            |       |  0.19

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:       315866 ave      315866 max      315866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315866
Ave neighs/atom = 78.9665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.99178918694, Press = 1.26330139338989
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11612.177     -11612.177     -11742.124     -11742.124      251.39244      251.39244      69581.74       69581.74       44.292429      44.292429    
     39000  -11615.503     -11615.503     -11746.416     -11746.416      253.25924      253.25924      69559.424      69559.424     -187.22299     -187.22299    
Loop time of 5.57985 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.484 ns/day, 1.550 hours/ns, 179.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    | 5.4266     | 5.4266     | 5.4266     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021497   | 0.021497   | 0.021497   |   0.0 |  0.39
Output  | 3.9414e-05 | 3.9414e-05 | 3.9414e-05 |   0.0 |  0.00
Modify  | 0.12139    | 0.12139    | 0.12139    |   0.0 |  2.18
Other   |            | 0.01035    |            |       |  0.19

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:       315938 ave      315938 max      315938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315938
Ave neighs/atom = 78.9845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.99364655266, Press = 1.1718047312746
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11615.503     -11615.503     -11746.416     -11746.416      253.25924      253.25924      69559.424      69559.424     -187.22299     -187.22299    
     40000  -11609.145     -11609.145     -11741.953     -11741.953      256.9245       256.9245       69662.793      69662.793     -1386.3306     -1386.3306    
Loop time of 5.58222 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.478 ns/day, 1.551 hours/ns, 179.140 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    | 5.429      | 5.429      | 5.429      |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021504   | 0.021504   | 0.021504   |   0.0 |  0.39
Output  | 3.1439e-05 | 3.1439e-05 | 3.1439e-05 |   0.0 |  0.00
Modify  | 0.12132    | 0.12132    | 0.12132    |   0.0 |  2.17
Other   |            | 0.01033    |            |       |  0.19

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:       315878 ave      315878 max      315878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315878
Ave neighs/atom = 78.9695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.028977607411, Press = 0.889553934943694
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11609.145     -11609.145     -11741.953     -11741.953      256.9245       256.9245       69662.793      69662.793     -1386.3306     -1386.3306    
     41000  -11612.274     -11612.274     -11743.49      -11743.49       253.8473       253.8473       69567.118      69567.118      160.27354      160.27354    
Loop time of 5.57578 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.496 ns/day, 1.549 hours/ns, 179.347 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    | 5.4224     | 5.4224     | 5.4224     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021581   | 0.021581   | 0.021581   |   0.0 |  0.39
Output  | 3.0507e-05 | 3.0507e-05 | 3.0507e-05 |   0.0 |  0.00
Modify  | 0.12138    | 0.12138    | 0.12138    |   0.0 |  2.18
Other   |            | 0.01034    |            |       |  0.19

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:       315774 ave      315774 max      315774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315774
Ave neighs/atom = 78.9435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.03771495236, Press = 1.45512718757275
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11612.274     -11612.274     -11743.49      -11743.49       253.8473       253.8473       69567.118      69567.118      160.27354      160.27354    
     42000  -11613.537     -11613.537     -11742.678     -11742.678      249.83265      249.83265      69595.278      69595.278     -209.29968     -209.29968    
Loop time of 5.58998 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.456 ns/day, 1.553 hours/ns, 178.892 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    | 5.4364     | 5.4364     | 5.4364     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021558   | 0.021558   | 0.021558   |   0.0 |  0.39
Output  | 3.0457e-05 | 3.0457e-05 | 3.0457e-05 |   0.0 |  0.00
Modify  | 0.12169    | 0.12169    | 0.12169    |   0.0 |  2.18
Other   |            | 0.01034    |            |       |  0.18

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:       315942 ave      315942 max      315942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315942
Ave neighs/atom = 78.9855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.018762739352, Press = 0.980433996690059
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11613.537     -11613.537     -11742.678     -11742.678      249.83265      249.83265      69595.278      69595.278     -209.29968     -209.29968    
     43000  -11612.324     -11612.324     -11743.048     -11743.048      252.89486      252.89486      69544.861      69544.861      683.63286      683.63286    
Loop time of 5.61878 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.377 ns/day, 1.561 hours/ns, 177.975 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    | 5.4647     | 5.4647     | 5.4647     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021566   | 0.021566   | 0.021566   |   0.0 |  0.38
Output  | 3.2081e-05 | 3.2081e-05 | 3.2081e-05 |   0.0 |  0.00
Modify  | 0.12212    | 0.12212    | 0.12212    |   0.0 |  2.17
Other   |            | 0.01035    |            |       |  0.18

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:       316056 ave      316056 max      316056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316056
Ave neighs/atom = 79.014
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.013128807725, Press = 1.29475350755128
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11612.324     -11612.324     -11743.048     -11743.048      252.89486      252.89486      69544.861      69544.861      683.63286      683.63286    
     44000  -11615.359     -11615.359     -11745.305     -11745.305      251.38894      251.38894      69557.831      69557.831      61.464475      61.464475    
Loop time of 5.58123 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.480 ns/day, 1.550 hours/ns, 179.172 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.4273     | 5.4273     | 5.4273     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021372   | 0.021372   | 0.021372   |   0.0 |  0.38
Output  | 3.2622e-05 | 3.2622e-05 | 3.2622e-05 |   0.0 |  0.00
Modify  | 0.12211    | 0.12211    | 0.12211    |   0.0 |  2.19
Other   |            | 0.01037    |            |       |  0.19

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:       316108 ave      316108 max      316108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316108
Ave neighs/atom = 79.027
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.010955853371, Press = 0.687897497224992
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11615.359     -11615.359     -11745.305     -11745.305      251.38894      251.38894      69557.831      69557.831      61.464475      61.464475    
     45000  -11611         -11611         -11742.316     -11742.316      254.04023      254.04023      69605.812      69605.812     -425.3449      -425.3449     
Loop time of 5.58628 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.466 ns/day, 1.552 hours/ns, 179.010 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    | 5.4325     | 5.4325     | 5.4325     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021316   | 0.021316   | 0.021316   |   0.0 |  0.38
Output  | 3.1018e-05 | 3.1018e-05 | 3.1018e-05 |   0.0 |  0.00
Modify  | 0.1221     | 0.1221     | 0.1221     |   0.0 |  2.19
Other   |            | 0.01031    |            |       |  0.18

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:       315908 ave      315908 max      315908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315908
Ave neighs/atom = 78.977
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.010103938435, Press = 0.366942549606121
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11611         -11611         -11742.316     -11742.316      254.04023      254.04023      69605.812      69605.812     -425.3449      -425.3449     
     46000  -11614.649     -11614.649     -11746.703     -11746.703      255.46874      255.46874      69470.251      69470.251      1445.4806      1445.4806    
Loop time of 5.52104 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.649 ns/day, 1.534 hours/ns, 181.125 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.3676     | 5.3676     | 5.3676     |   0.0 | 97.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021301   | 0.021301   | 0.021301   |   0.0 |  0.39
Output  | 3.2792e-05 | 3.2792e-05 | 3.2792e-05 |   0.0 |  0.00
Modify  | 0.12179    | 0.12179    | 0.12179    |   0.0 |  2.21
Other   |            | 0.01036    |            |       |  0.19

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:       315880 ave      315880 max      315880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315880
Ave neighs/atom = 78.97
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.972880646237, Press = 1.16515876954002
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11614.649     -11614.649     -11746.703     -11746.703      255.46874      255.46874      69470.251      69470.251      1445.4806      1445.4806    
     47000  -11612.986     -11612.986     -11743.011     -11743.011      251.54237      251.54237      69621.449      69621.449     -784.65916     -784.65916    
Loop time of 5.51669 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.662 ns/day, 1.532 hours/ns, 181.268 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    | 5.3632     | 5.3632     | 5.3632     |   0.0 | 97.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021283   | 0.021283   | 0.021283   |   0.0 |  0.39
Output  | 3.2441e-05 | 3.2441e-05 | 3.2441e-05 |   0.0 |  0.00
Modify  | 0.12181    | 0.12181    | 0.12181    |   0.0 |  2.21
Other   |            | 0.01037    |            |       |  0.19

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:       316104 ave      316104 max      316104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316104
Ave neighs/atom = 79.026
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.000488079312, Press = -0.401254862196653
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11612.986     -11612.986     -11743.011     -11743.011      251.54237      251.54237      69621.449      69621.449     -784.65916     -784.65916    
     48000  -11617.411     -11617.411     -11749.266     -11749.266      255.0822       255.0822       69543.846      69543.846     -288.00726     -288.00726    
Loop time of 5.52201 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.646 ns/day, 1.534 hours/ns, 181.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    | 5.3686     | 5.3686     | 5.3686     |   0.0 | 97.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021219   | 0.021219   | 0.021219   |   0.0 |  0.38
Output  | 3.3463e-05 | 3.3463e-05 | 3.3463e-05 |   0.0 |  0.00
Modify  | 0.12179    | 0.12179    | 0.12179    |   0.0 |  2.21
Other   |            | 0.01037    |            |       |  0.19

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:       315984 ave      315984 max      315984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315984
Ave neighs/atom = 78.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.002186838054, Press = -0.230952288386486
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11617.411     -11617.411     -11749.266     -11749.266      255.0822       255.0822       69543.846      69543.846     -288.00726     -288.00726    
     49000  -11613.107     -11613.107     -11742.644     -11742.644      250.59876      250.59876      69579.455      69579.455      44.484         44.484       
Loop time of 5.49073 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.736 ns/day, 1.525 hours/ns, 182.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    | 5.3375     | 5.3375     | 5.3375     |   0.0 | 97.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021296   | 0.021296   | 0.021296   |   0.0 |  0.39
Output  | 3.0357e-05 | 3.0357e-05 | 3.0357e-05 |   0.0 |  0.00
Modify  | 0.12159    | 0.12159    | 0.12159    |   0.0 |  2.21
Other   |            | 0.01032    |            |       |  0.19

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:       315904 ave      315904 max      315904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315904
Ave neighs/atom = 78.976
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.990455674131, Press = 0.557104267280164
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11613.107     -11613.107     -11742.644     -11742.644      250.59876      250.59876      69579.455      69579.455      44.484         44.484       
     50000  -11617.496     -11617.496     -11745.52      -11745.52       247.66996      247.66996      69637.483      69637.483     -1456.5917     -1456.5917    
Loop time of 5.50628 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.691 ns/day, 1.530 hours/ns, 181.611 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    | 5.353      | 5.353      | 5.353      |   0.0 | 97.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021268   | 0.021268   | 0.021268   |   0.0 |  0.39
Output  | 4.1348e-05 | 4.1348e-05 | 4.1348e-05 |   0.0 |  0.00
Modify  | 0.12163    | 0.12163    | 0.12163    |   0.0 |  2.21
Other   |            | 0.01032    |            |       |  0.19

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:       315916 ave      315916 max      315916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315916
Ave neighs/atom = 78.979
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.956719674981, Press = 1.46258950646003
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11617.496     -11617.496     -11745.52      -11745.52       247.66996      247.66996      69637.483      69637.483     -1456.5917     -1456.5917    
     51000  -11611.522     -11611.522     -11743.286     -11743.286      254.90523      254.90523      69521.3        69521.3        1000.4947      1000.4947    
Loop time of 5.46816 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.801 ns/day, 1.519 hours/ns, 182.877 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    | 5.3149     | 5.3149     | 5.3149     |   0.0 | 97.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021203   | 0.021203   | 0.021203   |   0.0 |  0.39
Output  | 3.203e-05  | 3.203e-05  | 3.203e-05  |   0.0 |  0.00
Modify  | 0.12166    | 0.12166    | 0.12166    |   0.0 |  2.22
Other   |            | 0.01033    |            |       |  0.19

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:       315744 ave      315744 max      315744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315744
Ave neighs/atom = 78.936
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.946789132163, Press = 1.40008560500525
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11611.522     -11611.522     -11743.286     -11743.286      254.90523      254.90523      69521.3        69521.3        1000.4947      1000.4947    
     52000  -11617.122     -11617.122     -11745.78      -11745.78       248.89869      248.89869      69519.989      69519.989      647.80893      647.80893    
Loop time of 5.50808 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.686 ns/day, 1.530 hours/ns, 181.551 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    | 5.3539     | 5.3539     | 5.3539     |   0.0 | 97.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021378   | 0.021378   | 0.021378   |   0.0 |  0.39
Output  | 3.4214e-05 | 3.4214e-05 | 3.4214e-05 |   0.0 |  0.00
Modify  | 0.12246    | 0.12246    | 0.12246    |   0.0 |  2.22
Other   |            | 0.0103     |            |       |  0.19

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:       316100 ave      316100 max      316100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316100
Ave neighs/atom = 79.025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.909496978585, Press = 0.465924327098148
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11617.122     -11617.122     -11745.78      -11745.78       248.89869      248.89869      69519.989      69519.989      647.80893      647.80893    
     53000  -11612.994     -11612.994     -11743.705     -11743.705      252.86819      252.86819      69534.488      69534.488      645.14712      645.14712    
Loop time of 5.50385 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.698 ns/day, 1.529 hours/ns, 181.691 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    | 5.3505     | 5.3505     | 5.3505     |   0.0 | 97.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021302   | 0.021302   | 0.021302   |   0.0 |  0.39
Output  | 3.1209e-05 | 3.1209e-05 | 3.1209e-05 |   0.0 |  0.00
Modify  | 0.12168    | 0.12168    | 0.12168    |   0.0 |  2.21
Other   |            | 0.01033    |            |       |  0.19

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:       315982 ave      315982 max      315982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315982
Ave neighs/atom = 78.9955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.919158542532, Press = 0.448757873324754
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11612.994     -11612.994     -11743.705     -11743.705      252.86819      252.86819      69534.488      69534.488      645.14712      645.14712    
     54000  -11613.014     -11613.014     -11746.409     -11746.409      258.06309      258.06309      69554.27       69554.27       12.560628      12.560628    
Loop time of 5.51167 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.676 ns/day, 1.531 hours/ns, 181.433 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    | 5.3581     | 5.3581     | 5.3581     |   0.0 | 97.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021224   | 0.021224   | 0.021224   |   0.0 |  0.39
Output  | 3.0868e-05 | 3.0868e-05 | 3.0868e-05 |   0.0 |  0.00
Modify  | 0.12194    | 0.12194    | 0.12194    |   0.0 |  2.21
Other   |            | 0.01033    |            |       |  0.19

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:       316108 ave      316108 max      316108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316108
Ave neighs/atom = 79.027
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.950482087478, Press = -0.29150265328974
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11613.014     -11613.014     -11746.409     -11746.409      258.06309      258.06309      69554.27       69554.27       12.560628      12.560628    
     55000  -11613.45      -11613.45      -11741.891     -11741.891      248.4765       248.4765       69563.18       69563.18       359.95443      359.95443    
Loop time of 5.5132 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.671 ns/day, 1.531 hours/ns, 181.383 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    | 5.3598     | 5.3598     | 5.3598     |   0.0 | 97.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021334   | 0.021334   | 0.021334   |   0.0 |  0.39
Output  | 3.179e-05  | 3.179e-05  | 3.179e-05  |   0.0 |  0.00
Modify  | 0.12166    | 0.12166    | 0.12166    |   0.0 |  2.21
Other   |            | 0.01036    |            |       |  0.19

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:       315996 ave      315996 max      315996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315996
Ave neighs/atom = 78.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.960798229286, Press = 0.933079254383962
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11613.45      -11613.45      -11741.891     -11741.891      248.4765       248.4765       69563.18       69563.18       359.95443      359.95443    
     56000  -11611.26      -11611.26      -11741.971     -11741.971      252.86937      252.86937      69526.587      69526.587      1086.0063      1086.0063    
Loop time of 5.52257 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.645 ns/day, 1.534 hours/ns, 181.075 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    | 5.369      | 5.369      | 5.369      |   0.0 | 97.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021325   | 0.021325   | 0.021325   |   0.0 |  0.39
Output  | 3.178e-05  | 3.178e-05  | 3.178e-05  |   0.0 |  0.00
Modify  | 0.12185    | 0.12185    | 0.12185    |   0.0 |  2.21
Other   |            | 0.01035    |            |       |  0.19

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:       315972 ave      315972 max      315972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315972
Ave neighs/atom = 78.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.981306990788, Press = 0.535701063311053
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11611.26      -11611.26      -11741.971     -11741.971      252.86937      252.86937      69526.587      69526.587      1086.0063      1086.0063    
     57000  -11611.581     -11611.581     -11742.659     -11742.659      253.57904      253.57904      69595.23       69595.23      -179.26671     -179.26671    
Loop time of 5.48526 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.751 ns/day, 1.524 hours/ns, 182.307 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    | 5.332      | 5.332      | 5.332      |   0.0 | 97.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021211   | 0.021211   | 0.021211   |   0.0 |  0.39
Output  | 3.4044e-05 | 3.4044e-05 | 3.4044e-05 |   0.0 |  0.00
Modify  | 0.12165    | 0.12165    | 0.12165    |   0.0 |  2.22
Other   |            | 0.01031    |            |       |  0.19

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:       316144 ave      316144 max      316144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316144
Ave neighs/atom = 79.036
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.984864633609, Press = 0.207941395504984
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11611.581     -11611.581     -11742.659     -11742.659      253.57904      253.57904      69595.23       69595.23      -179.26671     -179.26671    
     58000  -11614.411     -11614.411     -11743.403     -11743.403      249.54464      249.54464      69565.177      69565.177      188.2726       188.2726     
Loop time of 5.52602 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.635 ns/day, 1.535 hours/ns, 180.962 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    | 5.3724     | 5.3724     | 5.3724     |   0.0 | 97.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021302   | 0.021302   | 0.021302   |   0.0 |  0.39
Output  | 3.7821e-05 | 3.7821e-05 | 3.7821e-05 |   0.0 |  0.00
Modify  | 0.12195    | 0.12195    | 0.12195    |   0.0 |  2.21
Other   |            | 0.01034    |            |       |  0.19

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:       316116 ave      316116 max      316116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316116
Ave neighs/atom = 79.029
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.976324933783, Press = 0.273187407297827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11614.411     -11614.411     -11743.403     -11743.403      249.54464      249.54464      69565.177      69565.177      188.2726       188.2726     
     59000  -11608.438     -11608.438     -11742.802     -11742.802      259.93554      259.93554      69663.395      69663.395     -1341.0904     -1341.0904    
Loop time of 5.5364 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.606 ns/day, 1.538 hours/ns, 180.623 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    | 5.3826     | 5.3826     | 5.3826     |   0.0 | 97.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021357   | 0.021357   | 0.021357   |   0.0 |  0.39
Output  | 3.22e-05   | 3.22e-05   | 3.22e-05   |   0.0 |  0.00
Modify  | 0.12202    | 0.12202    | 0.12202    |   0.0 |  2.20
Other   |            | 0.01036    |            |       |  0.19

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:       316000 ave      316000 max      316000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316000
Ave neighs/atom = 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 = 252.992113505919, Press = 0.677455234608601
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      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  -11608.438     -11608.438     -11742.802     -11742.802      259.93554      259.93554      69663.395      69663.395     -1341.0904     -1341.0904    
     60000  -11614.562     -11614.562     -11743.191     -11743.191      248.84262      248.84262      69621.174      69621.174     -845.37829     -845.37829    
Loop time of 5.53318 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.615 ns/day, 1.537 hours/ns, 180.728 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    | 5.3797     | 5.3797     | 5.3797     |   0.0 | 97.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021346   | 0.021346   | 0.021346   |   0.0 |  0.39
Output  | 3.0758e-05 | 3.0758e-05 | 3.0758e-05 |   0.0 |  0.00
Modify  | 0.12176    | 0.12176    | 0.12176    |   0.0 |  2.20
Other   |            | 0.01036    |            |       |  0.19

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:       315906 ave      315906 max      315906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315906
Ave neighs/atom = 78.9765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
69569.2922873012

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0