# 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.072935052216053*${_u_distance}
variable latticeconst_converted equal 4.072935052216053*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.07293505221605
Lattice spacing in x,y,z = 4.0729351 4.0729351 4.0729351
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.729351 40.729351 40.729351)
  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.729351 40.729351 40.729351)
  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 MEAM_LAMMPS_KangSaLee_2009_ZrAgCu__MO_813575892799_002
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 67565.1047480748    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 67565.1047480748/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 67565.1047480748/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 67565.1047480748/(1*1*${_u_distance})
variable      V0_metal equal 67565.1047480748/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 67565.1047480748*1000

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_813575892799_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11238.129     -11238.129     -11400         -11400          313.15         313.15         67565.105      67565.105      2558.9641      2558.9641    
      1000  -11066.939     -11066.939     -11225.7       -11225.7        307.13449      307.13449      68940.572      68940.572      360.50279      360.50279    
Loop time of 42.5991 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.028 ns/day, 11.833 hours/ns, 23.475 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    | 42.449     | 42.449     | 42.449     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021669   | 0.021669   | 0.021669   |   0.0 |  0.05
Output  | 0.00011119 | 0.00011119 | 0.00011119 |   0.0 |  0.00
Modify  | 0.11783    | 0.11783    | 0.11783    |   0.0 |  0.28
Other   |            | 0.01045    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11066.939     -11066.939     -11225.7       -11225.7        307.13449      307.13449      68940.572      68940.572      360.50279      360.50279    
      2000  -11082.472     -11082.472     -11241.932     -11241.932      308.4869       308.4869       68738.505      68738.505      1809.8285      1809.8285    
Loop time of 47.2199 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.830 ns/day, 13.117 hours/ns, 21.177 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    | 47.07      | 47.07      | 47.07      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021692   | 0.021692   | 0.021692   |   0.0 |  0.05
Output  | 6.0454e-05 | 6.0454e-05 | 6.0454e-05 |   0.0 |  0.00
Modify  | 0.11744    | 0.11744    | 0.11744    |   0.0 |  0.25
Other   |            | 0.01031    |            |       |  0.02

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

Total # of neighbors = 318930
Ave neighs/atom = 79.7325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11082.472     -11082.472     -11241.932     -11241.932      308.4869       308.4869       68738.505      68738.505      1809.8285      1809.8285    
      3000  -11075         -11075         -11241.168     -11241.168      321.4641       321.4641       68899.307      68899.307     -468.26509     -468.26509    
Loop time of 47.4158 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.822 ns/day, 13.171 hours/ns, 21.090 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    | 47.266     | 47.266     | 47.266     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021822   | 0.021822   | 0.021822   |   0.0 |  0.05
Output  | 6.1055e-05 | 6.1055e-05 | 6.1055e-05 |   0.0 |  0.00
Modify  | 0.11731    | 0.11731    | 0.11731    |   0.0 |  0.25
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 319024
Ave neighs/atom = 79.756
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11075         -11075         -11241.168     -11241.168      321.4641       321.4641       68899.307      68899.307     -468.26509     -468.26509    
      4000  -11075.779     -11075.779     -11238.601     -11238.601      314.99069      314.99069      68847.463      68847.463      430.90351      430.90351    
Loop time of 47.4851 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.820 ns/day, 13.190 hours/ns, 21.059 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    | 47.336     | 47.336     | 47.336     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021639   | 0.021639   | 0.021639   |   0.0 |  0.05
Output  | 6.2488e-05 | 6.2488e-05 | 6.2488e-05 |   0.0 |  0.00
Modify  | 0.1173     | 0.1173     | 0.1173     |   0.0 |  0.25
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 318666
Ave neighs/atom = 79.6665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11075.779     -11075.779     -11238.601     -11238.601      314.99069      314.99069      68847.463      68847.463      430.90351      430.90351    
      5000  -11080.336     -11080.336     -11238.989     -11238.989      306.92416      306.92416      68880.127      68880.127     -220.17229     -220.17229    
Loop time of 47.4237 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.822 ns/day, 13.173 hours/ns, 21.087 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    | 47.274     | 47.274     | 47.274     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021782   | 0.021782   | 0.021782   |   0.0 |  0.05
Output  | 4.262e-05  | 4.262e-05  | 4.262e-05  |   0.0 |  0.00
Modify  | 0.1177     | 0.1177     | 0.1177     |   0.0 |  0.25
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 318778
Ave neighs/atom = 79.6945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.249464813725, Press = 149.769984402798
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11080.336     -11080.336     -11238.989     -11238.989      306.92416      306.92416      68880.127      68880.127     -220.17229     -220.17229    
      6000  -11077.329     -11077.329     -11236.314     -11236.314      307.56836      307.56836      68910.051      68910.051     -404.26493     -404.26493    
Loop time of 47.5178 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.818 ns/day, 13.199 hours/ns, 21.045 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    | 47.365     | 47.365     | 47.365     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021705   | 0.021705   | 0.021705   |   0.0 |  0.05
Output  | 4.7469e-05 | 4.7469e-05 | 4.7469e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.25
Other   |            | 0.01029    |            |       |  0.02

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

Total # of neighbors = 318730
Ave neighs/atom = 79.6825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.896098214346, Press = 16.2308059844203
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11077.329     -11077.329     -11236.314     -11236.314      307.56836      307.56836      68910.051      68910.051     -404.26493     -404.26493    
      7000  -11079.681     -11079.681     -11235.755     -11235.755      301.93643      301.93643      68872.238      68872.238      199.63249      199.63249    
Loop time of 47.578 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.216 hours/ns, 21.018 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    | 47.425     | 47.425     | 47.425     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021626   | 0.021626   | 0.021626   |   0.0 |  0.05
Output  | 3.9324e-05 | 3.9324e-05 | 3.9324e-05 |   0.0 |  0.00
Modify  | 0.12097    | 0.12097    | 0.12097    |   0.0 |  0.25
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 318818
Ave neighs/atom = 79.7045
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.85377774287, Press = -14.3853077804737
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11079.681     -11079.681     -11235.755     -11235.755      301.93643      301.93643      68872.238      68872.238      199.63249      199.63249    
      8000  -11081.79      -11081.79      -11242.52      -11242.52       310.94318      310.94318      68805.707      68805.707      654.6306       654.6306     
Loop time of 47.4433 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.821 ns/day, 13.179 hours/ns, 21.078 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    | 47.291     | 47.291     | 47.291     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021665   | 0.021665   | 0.021665   |   0.0 |  0.05
Output  | 2.9986e-05 | 2.9986e-05 | 2.9986e-05 |   0.0 |  0.00
Modify  | 0.12073    | 0.12073    | 0.12073    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318876
Ave neighs/atom = 79.719
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.136635473082, Press = 6.25413852698643
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11081.79      -11081.79      -11242.52      -11242.52       310.94318      310.94318      68805.707      68805.707      654.6306       654.6306     
      9000  -11076.436     -11076.436     -11236.719     -11236.719      310.07778      310.07778      68909.611      68909.611     -329.1087      -329.1087     
Loop time of 47.4745 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.820 ns/day, 13.187 hours/ns, 21.064 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    | 47.322     | 47.322     | 47.322     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021659   | 0.021659   | 0.021659   |   0.0 |  0.05
Output  | 3.8332e-05 | 3.8332e-05 | 3.8332e-05 |   0.0 |  0.00
Modify  | 0.12084    | 0.12084    | 0.12084    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318966
Ave neighs/atom = 79.7415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.903139441802, Press = 4.02593601301009
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11076.436     -11076.436     -11236.719     -11236.719      310.07778      310.07778      68909.611      68909.611     -329.1087      -329.1087     
     10000  -11082.075     -11082.075     -11241.872     -11241.872      309.13751      309.13751      68763.648      68763.648      1356.4422      1356.4422    
Loop time of 47.6738 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.243 hours/ns, 20.976 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    | 47.521     | 47.521     | 47.521     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021813   | 0.021813   | 0.021813   |   0.0 |  0.05
Output  | 3.8773e-05 | 3.8773e-05 | 3.8773e-05 |   0.0 |  0.00
Modify  | 0.12095    | 0.12095    | 0.12095    |   0.0 |  0.25
Other   |            | 0.01012    |            |       |  0.02

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

Total # of neighbors = 318776
Ave neighs/atom = 79.694
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.099039672665, Press = 7.41087374530613
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11082.075     -11082.075     -11241.872     -11241.872      309.13751      309.13751      68763.648      68763.648      1356.4422      1356.4422    
     11000  -11080.288     -11080.288     -11238.461     -11238.461      305.9967       305.9967       68951.367      68951.367     -1135.7629     -1135.7629    
Loop time of 47.7584 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.809 ns/day, 13.266 hours/ns, 20.939 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    | 47.605     | 47.605     | 47.605     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02179    | 0.02179    | 0.02179    |   0.0 |  0.05
Output  | 3.7671e-05 | 3.7671e-05 | 3.7671e-05 |   0.0 |  0.00
Modify  | 0.12101    | 0.12101    | 0.12101    |   0.0 |  0.25
Other   |            | 0.01012    |            |       |  0.02

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

Total # of neighbors = 319080
Ave neighs/atom = 79.77
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.152634515322, Press = 2.460301890725
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11080.288     -11080.288     -11238.461     -11238.461      305.9967       305.9967       68951.367      68951.367     -1135.7629     -1135.7629    
     12000  -11075.781     -11075.781     -11240.198     -11240.198      318.07647      318.07647      68770.296      68770.296      1491.6082      1491.6082    
Loop time of 47.6996 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.811 ns/day, 13.250 hours/ns, 20.965 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    | 47.547     | 47.547     | 47.547     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021772   | 0.021772   | 0.021772   |   0.0 |  0.05
Output  | 3.71e-05   | 3.71e-05   | 3.71e-05   |   0.0 |  0.00
Modify  | 0.12095    | 0.12095    | 0.12095    |   0.0 |  0.25
Other   |            | 0.01012    |            |       |  0.02

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

Total # of neighbors = 318540
Ave neighs/atom = 79.635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.935204530193, Press = -2.525606223644
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11075.781     -11075.781     -11240.198     -11240.198      318.07647      318.07647      68770.296      68770.296      1491.6082      1491.6082    
     13000  -11080.507     -11080.507     -11239.423     -11239.423      307.43504      307.43504      68903.737      68903.737     -501.12577     -501.12577    
Loop time of 47.6259 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.229 hours/ns, 20.997 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    | 47.473     | 47.473     | 47.473     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021754   | 0.021754   | 0.021754   |   0.0 |  0.05
Output  | 2.8814e-05 | 2.8814e-05 | 2.8814e-05 |   0.0 |  0.00
Modify  | 0.12078    | 0.12078    | 0.12078    |   0.0 |  0.25
Other   |            | 0.01013    |            |       |  0.02

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

Total # of neighbors = 319020
Ave neighs/atom = 79.755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.893173904341, Press = 5.39690721324834
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11080.507     -11080.507     -11239.423     -11239.423      307.43504      307.43504      68903.737      68903.737     -501.12577     -501.12577    
     14000  -11078.861     -11078.861     -11236.66      -11236.66       305.27471      305.27471      68872.332      68872.332      271.42111      271.42111    
Loop time of 47.6702 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.242 hours/ns, 20.977 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    | 47.517     | 47.517     | 47.517     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021856   | 0.021856   | 0.021856   |   0.0 |  0.05
Output  | 6.0734e-05 | 6.0734e-05 | 6.0734e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.25
Other   |            | 0.01013    |            |       |  0.02

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

Total # of neighbors = 318728
Ave neighs/atom = 79.682
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.682233359643, Press = 2.49084766334287
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11078.861     -11078.861     -11236.66      -11236.66       305.27471      305.27471      68872.332      68872.332      271.42111      271.42111    
     15000  -11082.084     -11082.084     -11243.849     -11243.849      312.94584      312.94584      68786.088      68786.088      846.508        846.508      
Loop time of 47.7322 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.810 ns/day, 13.259 hours/ns, 20.950 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 47.579     | 47.579     | 47.579     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021935   | 0.021935   | 0.021935   |   0.0 |  0.05
Output  | 4.0015e-05 | 4.0015e-05 | 4.0015e-05 |   0.0 |  0.00
Modify  | 0.12075    | 0.12075    | 0.12075    |   0.0 |  0.25
Other   |            | 0.01015    |            |       |  0.02

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

Total # of neighbors = 318756
Ave neighs/atom = 79.689
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.776647872754, Press = -2.11897479439985
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11082.084     -11082.084     -11243.849     -11243.849      312.94584      312.94584      68786.088      68786.088      846.508        846.508      
     16000  -11075.275     -11075.275     -11238.802     -11238.802      316.35361      316.35361      68923.294      68923.294     -656.74917     -656.74917    
Loop time of 47.7187 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.811 ns/day, 13.255 hours/ns, 20.956 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    | 47.566     | 47.566     | 47.566     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021803   | 0.021803   | 0.021803   |   0.0 |  0.05
Output  | 4.6548e-05 | 4.6548e-05 | 4.6548e-05 |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318878
Ave neighs/atom = 79.7195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.627203613264, Press = 2.17736302303923
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11075.275     -11075.275     -11238.802     -11238.802      316.35361      316.35361      68923.294      68923.294     -656.74917     -656.74917    
     17000  -11079.533     -11079.533     -11240.422     -11240.422      311.25174      311.25174      68831.16       68831.16       522.73839      522.73839    
Loop time of 47.6554 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.238 hours/ns, 20.984 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    | 47.503     | 47.503     | 47.503     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021707   | 0.021707   | 0.021707   |   0.0 |  0.05
Output  | 3.7932e-05 | 3.7932e-05 | 3.7932e-05 |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.25
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 318694
Ave neighs/atom = 79.6735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.636973140167, Press = 1.87957525226808
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11079.533     -11079.533     -11240.422     -11240.422      311.25174      311.25174      68831.16       68831.16       522.73839      522.73839    
     18000  -11076.427     -11076.427     -11239.465     -11239.465      315.40982      315.40982      68928.144      68928.144     -699.78248     -699.78248    
Loop time of 47.6677 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.241 hours/ns, 20.979 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    | 47.515     | 47.515     | 47.515     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021787   | 0.021787   | 0.021787   |   0.0 |  0.05
Output  | 3.3253e-05 | 3.3253e-05 | 3.3253e-05 |   0.0 |  0.00
Modify  | 0.12068    | 0.12068    | 0.12068    |   0.0 |  0.25
Other   |            | 0.01017    |            |       |  0.02

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

Total # of neighbors = 318920
Ave neighs/atom = 79.73
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.624838928975, Press = -0.817485950808833
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11076.427     -11076.427     -11239.465     -11239.465      315.40982      315.40982      68928.144      68928.144     -699.78248     -699.78248    
     19000  -11073.022     -11073.022     -11235.303     -11235.303      313.94479      313.94479      68864.419      68864.419      536.63431      536.63431    
Loop time of 47.6228 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.229 hours/ns, 20.998 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    | 47.47      | 47.47      | 47.47      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021729   | 0.021729   | 0.021729   |   0.0 |  0.05
Output  | 3.9184e-05 | 3.9184e-05 | 3.9184e-05 |   0.0 |  0.00
Modify  | 0.12084    | 0.12084    | 0.12084    |   0.0 |  0.25
Other   |            | 0.01017    |            |       |  0.02

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

Total # of neighbors = 318516
Ave neighs/atom = 79.629
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.674370515389, Press = 2.32334726120663
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11073.022     -11073.022     -11235.303     -11235.303      313.94479      313.94479      68864.419      68864.419      536.63431      536.63431    
     20000  -11078.694     -11078.694     -11240.46      -11240.46       312.94635      312.94635      68852.701      68852.701      140.32342      140.32342    
Loop time of 47.755 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.809 ns/day, 13.265 hours/ns, 20.940 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 47.602     | 47.602     | 47.602     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021958   | 0.021958   | 0.021958   |   0.0 |  0.05
Output  | 3.7481e-05 | 3.7481e-05 | 3.7481e-05 |   0.0 |  0.00
Modify  | 0.12097    | 0.12097    | 0.12097    |   0.0 |  0.25
Other   |            | 0.01011    |            |       |  0.02

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

Total # of neighbors = 318872
Ave neighs/atom = 79.718
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.709441818637, Press = -1.18119766703827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11078.694     -11078.694     -11240.46      -11240.46       312.94635      312.94635      68852.701      68852.701      140.32342      140.32342    
     21000  -11082.726     -11082.726     -11241.857     -11241.857      307.8509       307.8509       68858.122      68858.122     -80.953168     -80.953168    
Loop time of 47.7559 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.809 ns/day, 13.266 hours/ns, 20.940 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 47.603     | 47.603     | 47.603     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02183    | 0.02183    | 0.02183    |   0.0 |  0.05
Output  | 4.2941e-05 | 4.2941e-05 | 4.2941e-05 |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  0.25
Other   |            | 0.01013    |            |       |  0.02

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

Total # of neighbors = 318870
Ave neighs/atom = 79.7175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.716964549401, Press = 1.29643645307647
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11082.726     -11082.726     -11241.857     -11241.857      307.8509       307.8509       68858.122      68858.122     -80.953168     -80.953168    
     22000  -11074.522     -11074.522     -11238.368     -11238.368      316.97064      316.97064      68946.536      68946.536     -1008.2445     -1008.2445    
Loop time of 47.6404 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.233 hours/ns, 20.991 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    | 47.488     | 47.488     | 47.488     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021815   | 0.021815   | 0.021815   |   0.0 |  0.05
Output  | 4.0857e-05 | 4.0857e-05 | 4.0857e-05 |   0.0 |  0.00
Modify  | 0.12084    | 0.12084    | 0.12084    |   0.0 |  0.25
Other   |            | 0.01012    |            |       |  0.02

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

Total # of neighbors = 318670
Ave neighs/atom = 79.6675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.736808297697, Press = -0.52542333959777
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11074.522     -11074.522     -11238.368     -11238.368      316.97064      316.97064      68946.536      68946.536     -1008.2445     -1008.2445    
     23000  -11076.186     -11076.186     -11238.807     -11238.807      314.60253      314.60253      68833.694      68833.694      751.79975      751.79975    
Loop time of 47.5837 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.218 hours/ns, 21.016 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    | 47.431     | 47.431     | 47.431     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021834   | 0.021834   | 0.021834   |   0.0 |  0.05
Output  | 3.8152e-05 | 3.8152e-05 | 3.8152e-05 |   0.0 |  0.00
Modify  | 0.1209     | 0.1209     | 0.1209     |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318616
Ave neighs/atom = 79.654
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.802740873292, Press = 1.16857229679815
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11076.186     -11076.186     -11238.807     -11238.807      314.60253      314.60253      68833.694      68833.694      751.79975      751.79975    
     24000  -11078.432     -11078.432     -11239.774     -11239.774      312.12681      312.12681      68891.981      68891.981     -320.19074     -320.19074    
Loop time of 47.6031 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.223 hours/ns, 21.007 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    | 47.45      | 47.45      | 47.45      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021746   | 0.021746   | 0.021746   |   0.0 |  0.05
Output  | 3.8332e-05 | 3.8332e-05 | 3.8332e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.25
Other   |            | 0.01013    |            |       |  0.02

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

Total # of neighbors = 319022
Ave neighs/atom = 79.7555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.923630335778, Press = -0.213711760382777
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11078.432     -11078.432     -11239.774     -11239.774      312.12681      312.12681      68891.981      68891.981     -320.19074     -320.19074    
     25000  -11072.06      -11072.06      -11238.95      -11238.95       322.8594       322.8594       68817.253      68817.253      970.61097      970.61097    
Loop time of 47.6659 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.241 hours/ns, 20.979 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    | 47.513     | 47.513     | 47.513     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021773   | 0.021773   | 0.021773   |   0.0 |  0.05
Output  | 3.7511e-05 | 3.7511e-05 | 3.7511e-05 |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.25
Other   |            | 0.01011    |            |       |  0.02

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

Total # of neighbors = 318660
Ave neighs/atom = 79.665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.959829669846, Press = 2.05392147626338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11072.06      -11072.06      -11238.95      -11238.95       322.8594       322.8594       68817.253      68817.253      970.61097      970.61097    
     26000  -11077.239     -11077.239     -11234.879     -11234.879      304.96531      304.96531      68962.544      68962.544     -954.19808     -954.19808    
Loop time of 47.7162 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.811 ns/day, 13.255 hours/ns, 20.957 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    | 47.563     | 47.563     | 47.563     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02185    | 0.02185    | 0.02185    |   0.0 |  0.05
Output  | 3.7991e-05 | 3.7991e-05 | 3.7991e-05 |   0.0 |  0.00
Modify  | 0.12088    | 0.12088    | 0.12088    |   0.0 |  0.25
Other   |            | 0.0101     |            |       |  0.02

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

Total # of neighbors = 318910
Ave neighs/atom = 79.7275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.963050978222, Press = -1.29395860965884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11077.239     -11077.239     -11234.879     -11234.879      304.96531      304.96531      68962.544      68962.544     -954.19808     -954.19808    
     27000  -11079.568     -11079.568     -11240.466     -11240.466      311.26756      311.26756      68850.928      68850.928      351.91927      351.91927    
Loop time of 47.6841 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.246 hours/ns, 20.971 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    | 47.531     | 47.531     | 47.531     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02182    | 0.02182    | 0.02182    |   0.0 |  0.05
Output  | 3.5727e-05 | 3.5727e-05 | 3.5727e-05 |   0.0 |  0.00
Modify  | 0.12078    | 0.12078    | 0.12078    |   0.0 |  0.25
Other   |            | 0.01015    |            |       |  0.02

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

Total # of neighbors = 318694
Ave neighs/atom = 79.6735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.966769334589, Press = 1.7393083646066
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11079.568     -11079.568     -11240.466     -11240.466      311.26756      311.26756      68850.928      68850.928      351.91927      351.91927    
     28000  -11076.708     -11076.708     -11239.767     -11239.767      315.44988      315.44988      68905.461      68905.461     -485.02474     -485.02474    
Loop time of 47.6275 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.230 hours/ns, 20.996 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    | 47.475     | 47.475     | 47.475     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021615   | 0.021615   | 0.021615   |   0.0 |  0.05
Output  | 3.9694e-05 | 3.9694e-05 | 3.9694e-05 |   0.0 |  0.00
Modify  | 0.1207     | 0.1207     | 0.1207     |   0.0 |  0.25
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 318732
Ave neighs/atom = 79.683
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.925098818593, Press = 0.356159731208464
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11076.708     -11076.708     -11239.767     -11239.767      315.44988      315.44988      68905.461      68905.461     -485.02474     -485.02474    
     29000  -11077.028     -11077.028     -11239.902     -11239.902      315.09172      315.09172      68901.198      68901.198     -409.97927     -409.97927    
Loop time of 47.6823 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.245 hours/ns, 20.972 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    | 47.53      | 47.53      | 47.53      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021721   | 0.021721   | 0.021721   |   0.0 |  0.05
Output  | 3.8292e-05 | 3.8292e-05 | 3.8292e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.25
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 318542
Ave neighs/atom = 79.6355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.884338237601, Press = -0.934260491332103
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11077.028     -11077.028     -11239.902     -11239.902      315.09172      315.09172      68901.198      68901.198     -409.97927     -409.97927    
     30000  -11079.13      -11079.13      -11240.695     -11240.695      312.55789      312.55789      68834.86       68834.86       506.08195      506.08195    
Loop time of 47.6664 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.241 hours/ns, 20.979 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    | 47.513     | 47.513     | 47.513     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021947   | 0.021947   | 0.021947   |   0.0 |  0.05
Output  | 3.7881e-05 | 3.7881e-05 | 3.7881e-05 |   0.0 |  0.00
Modify  | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.25
Other   |            | 0.01011    |            |       |  0.02

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

Total # of neighbors = 318620
Ave neighs/atom = 79.655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.839624314218, Press = 1.61976638227874
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11079.13      -11079.13      -11240.695     -11240.695      312.55789      312.55789      68834.86       68834.86       506.08195      506.08195    
     31000  -11077.46      -11077.46      -11238.303     -11238.303      311.16221      311.16221      68917.042      68917.042     -481.97188     -481.97188    
Loop time of 47.6777 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.244 hours/ns, 20.974 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    | 47.525     | 47.525     | 47.525     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021855   | 0.021855   | 0.021855   |   0.0 |  0.05
Output  | 3.8343e-05 | 3.8343e-05 | 3.8343e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.25
Other   |            | 0.01011    |            |       |  0.02

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

Total # of neighbors = 318774
Ave neighs/atom = 79.6935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.784206284593, Press = 0.0561136871833289
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11077.46      -11077.46      -11238.303     -11238.303      311.16221      311.16221      68917.042      68917.042     -481.97188     -481.97188    
     32000  -11076.401     -11076.401     -11238.426     -11238.426      313.44939      313.44939      68897.165      68897.165     -210.22717     -210.22717    
Loop time of 47.631 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.231 hours/ns, 20.995 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    | 47.478     | 47.478     | 47.478     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021756   | 0.021756   | 0.021756   |   0.0 |  0.05
Output  | 2.8273e-05 | 2.8273e-05 | 2.8273e-05 |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.25
Other   |            | 0.01015    |            |       |  0.02

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

Total # of neighbors = 318636
Ave neighs/atom = 79.659
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.756158741955, Press = -0.232456677101838
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11076.401     -11076.401     -11238.426     -11238.426      313.44939      313.44939      68897.165      68897.165     -210.22717     -210.22717    
     33000  -11080.327     -11080.327     -11241.921     -11241.921      312.61406      312.61406      68849.771      68849.771      105.19203      105.19203    
Loop time of 47.658 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.238 hours/ns, 20.983 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    | 47.505     | 47.505     | 47.505     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021852   | 0.021852   | 0.021852   |   0.0 |  0.05
Output  | 3.7841e-05 | 3.7841e-05 | 3.7841e-05 |   0.0 |  0.00
Modify  | 0.12073    | 0.12073    | 0.12073    |   0.0 |  0.25
Other   |            | 0.01014    |            |       |  0.02

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

Total # of neighbors = 318794
Ave neighs/atom = 79.6985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.707041843358, Press = 0.483982525172277
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11080.327     -11080.327     -11241.921     -11241.921      312.61406      312.61406      68849.771      68849.771      105.19203      105.19203    
     34000  -11078.245     -11078.245     -11241.013     -11241.013      314.88616      314.88616      68898.132      68898.132     -566.964       -566.964      
Loop time of 47.6129 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.226 hours/ns, 21.003 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    | 47.46      | 47.46      | 47.46      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021735   | 0.021735   | 0.021735   |   0.0 |  0.05
Output  | 3.8001e-05 | 3.8001e-05 | 3.8001e-05 |   0.0 |  0.00
Modify  | 0.12078    | 0.12078    | 0.12078    |   0.0 |  0.25
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 318756
Ave neighs/atom = 79.689
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.688200128987, Press = -0.461550762640637
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11078.245     -11078.245     -11241.013     -11241.013      314.88616      314.88616      68898.132      68898.132     -566.964       -566.964      
     35000  -11076.407     -11076.407     -11236.996     -11236.996      310.67063      310.67063      68856.554      68856.554      486.9781       486.9781     
Loop time of 47.51 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.819 ns/day, 13.197 hours/ns, 21.048 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    | 47.357     | 47.357     | 47.357     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021676   | 0.021676   | 0.021676   |   0.0 |  0.05
Output  | 3.8052e-05 | 3.8052e-05 | 3.8052e-05 |   0.0 |  0.00
Modify  | 0.12069    | 0.12069    | 0.12069    |   0.0 |  0.25
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 318654
Ave neighs/atom = 79.6635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.653743835554, Press = 1.04400611923805
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11076.407     -11076.407     -11236.996     -11236.996      310.67063      310.67063      68856.554      68856.554      486.9781       486.9781     
     36000  -11075.194     -11075.194     -11236.819     -11236.819      312.67514      312.67514      68864.14       68864.14       368.95704      368.95704    
Loop time of 47.5704 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.214 hours/ns, 21.021 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    | 47.418     | 47.418     | 47.418     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02193    | 0.02193    | 0.02193    |   0.0 |  0.05
Output  | 3.721e-05  | 3.721e-05  | 3.721e-05  |   0.0 |  0.00
Modify  | 0.12075    | 0.12075    | 0.12075    |   0.0 |  0.25
Other   |            | 0.01013    |            |       |  0.02

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

Total # of neighbors = 318848
Ave neighs/atom = 79.712
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.726664958192, Press = -0.367200916299248
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11075.194     -11075.194     -11236.819     -11236.819      312.67514      312.67514      68864.14       68864.14       368.95704      368.95704    
     37000  -11075.995     -11075.995     -11239.138     -11239.138      315.61105      315.61105      68917.952      68917.952     -585.62551     -585.62551    
Loop time of 47.6266 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.230 hours/ns, 20.997 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    | 47.474     | 47.474     | 47.474     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021935   | 0.021935   | 0.021935   |   0.0 |  0.05
Output  | 2.8944e-05 | 2.8944e-05 | 2.8944e-05 |   0.0 |  0.00
Modify  | 0.12073    | 0.12073    | 0.12073    |   0.0 |  0.25
Other   |            | 0.0101     |            |       |  0.02

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

Total # of neighbors = 318772
Ave neighs/atom = 79.693
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.734294348894, Press = -0.508145227433948
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11075.995     -11075.995     -11239.138     -11239.138      315.61105      315.61105      68917.952      68917.952     -585.62551     -585.62551    
     38000  -11075.651     -11075.651     -11236.82      -11236.82       311.79186      311.79186      68885.624      68885.624      68.417798      68.417798    
Loop time of 47.578 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.216 hours/ns, 21.018 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    | 47.425     | 47.425     | 47.425     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021755   | 0.021755   | 0.021755   |   0.0 |  0.05
Output  | 3.7961e-05 | 3.7961e-05 | 3.7961e-05 |   0.0 |  0.00
Modify  | 0.12074    | 0.12074    | 0.12074    |   0.0 |  0.25
Other   |            | 0.0101     |            |       |  0.02

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

Total # of neighbors = 318670
Ave neighs/atom = 79.6675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.715196560297, Press = 1.83214240409022
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11075.651     -11075.651     -11236.82      -11236.82       311.79186      311.79186      68885.624      68885.624      68.417798      68.417798    
     39000  -11073.931     -11073.931     -11238.507     -11238.507      318.38249      318.38249      68842.237      68842.237      593.19228      593.19228    
Loop time of 47.5826 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.217 hours/ns, 21.016 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    | 47.43      | 47.43      | 47.43      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021854   | 0.021854   | 0.021854   |   0.0 |  0.05
Output  | 3.8323e-05 | 3.8323e-05 | 3.8323e-05 |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.25
Other   |            | 0.01012    |            |       |  0.02

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

Total # of neighbors = 318696
Ave neighs/atom = 79.674
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.714356500218, Press = -0.711589434507371
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11073.931     -11073.931     -11238.507     -11238.507      318.38249      318.38249      68842.237      68842.237      593.19228      593.19228    
     40000  -11081.376     -11081.376     -11238.683     -11238.683      304.32227      304.32227      68892.955      68892.955     -334.90334     -334.90334    
Loop time of 47.748 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.810 ns/day, 13.263 hours/ns, 20.943 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    | 47.595     | 47.595     | 47.595     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022014   | 0.022014   | 0.022014   |   0.0 |  0.05
Output  | 3.7601e-05 | 3.7601e-05 | 3.7601e-05 |   0.0 |  0.00
Modify  | 0.12092    | 0.12092    | 0.12092    |   0.0 |  0.25
Other   |            | 0.01013    |            |       |  0.02

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

Total # of neighbors = 318962
Ave neighs/atom = 79.7405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.754734991783, Press = 0.626616163362112
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11081.376     -11081.376     -11238.683     -11238.683      304.32227      304.32227      68892.955      68892.955     -334.90334     -334.90334    
     41000  -11073.724     -11073.724     -11237.533     -11237.533      316.89942      316.89942      68898.828      68898.828     -146.35898     -146.35898    
Loop time of 47.6887 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.247 hours/ns, 20.969 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    | 47.536     | 47.536     | 47.536     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021842   | 0.021842   | 0.021842   |   0.0 |  0.05
Output  | 3.7341e-05 | 3.7341e-05 | 3.7341e-05 |   0.0 |  0.00
Modify  | 0.12084    | 0.12084    | 0.12084    |   0.0 |  0.25
Other   |            | 0.01011    |            |       |  0.02

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

Total # of neighbors = 318838
Ave neighs/atom = 79.7095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.733625201683, Press = -0.58089600658823
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11073.724     -11073.724     -11237.533     -11237.533      316.89942      316.89942      68898.828      68898.828     -146.35898     -146.35898    
     42000  -11080.443     -11080.443     -11241.19      -11241.19       310.97659      310.97659      68842.67       68842.67       312.28092      312.28092    
Loop time of 47.6076 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.224 hours/ns, 21.005 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    | 47.455     | 47.455     | 47.455     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021634   | 0.021634   | 0.021634   |   0.0 |  0.05
Output  | 3.0458e-05 | 3.0458e-05 | 3.0458e-05 |   0.0 |  0.00
Modify  | 0.12077    | 0.12077    | 0.12077    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318668
Ave neighs/atom = 79.667
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.772351510726, Press = 0.287662748584617
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11080.443     -11080.443     -11241.19      -11241.19       310.97659      310.97659      68842.67       68842.67       312.28092      312.28092    
     43000  -11080.715     -11080.715     -11241.799     -11241.799      311.62679      311.62679      68870.989      68870.989     -156.00138     -156.00138    
Loop time of 47.6548 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.237 hours/ns, 20.984 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    | 47.502     | 47.502     | 47.502     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021864   | 0.021864   | 0.021864   |   0.0 |  0.05
Output  | 3.7891e-05 | 3.7891e-05 | 3.7891e-05 |   0.0 |  0.00
Modify  | 0.12084    | 0.12084    | 0.12084    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318796
Ave neighs/atom = 79.699
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.727823774881, Press = 0.120402458960358
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11080.715     -11080.715     -11241.799     -11241.799      311.62679      311.62679      68870.989      68870.989     -156.00138     -156.00138    
     44000  -11075.793     -11075.793     -11237.26      -11237.26       312.36888      312.36888      68789.372      68789.372      1536.8308      1536.8308    
Loop time of 47.5598 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.211 hours/ns, 21.026 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    | 47.407     | 47.407     | 47.407     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021706   | 0.021706   | 0.021706   |   0.0 |  0.05
Output  | 3.8983e-05 | 3.8983e-05 | 3.8983e-05 |   0.0 |  0.00
Modify  | 0.12083    | 0.12083    | 0.12083    |   0.0 |  0.25
Other   |            | 0.01017    |            |       |  0.02

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

Total # of neighbors = 318716
Ave neighs/atom = 79.679
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.712941466135, Press = 0.874790399868363
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11075.793     -11075.793     -11237.26      -11237.26       312.36888      312.36888      68789.372      68789.372      1536.8308      1536.8308    
     45000  -11078.65      -11078.65      -11239.098     -11239.098      310.39854      310.39854      68926.3        68926.3       -826.52525     -826.52525    
Loop time of 47.6708 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.242 hours/ns, 20.977 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    | 47.518     | 47.518     | 47.518     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021949   | 0.021949   | 0.021949   |   0.0 |  0.05
Output  | 3.9094e-05 | 3.9094e-05 | 3.9094e-05 |   0.0 |  0.00
Modify  | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.25
Other   |            | 0.01012    |            |       |  0.02

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

Total # of neighbors = 319110
Ave neighs/atom = 79.7775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.707395625253, Press = -0.515117423627062
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11078.65      -11078.65      -11239.098     -11239.098      310.39854      310.39854      68926.3        68926.3       -826.52525     -826.52525    
     46000  -11076.543     -11076.543     -11240.126     -11240.126      316.46062      316.46062      68837.995      68837.995      436.91118      436.91118    
Loop time of 47.7566 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.809 ns/day, 13.266 hours/ns, 20.940 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 47.604     | 47.604     | 47.604     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021842   | 0.021842   | 0.021842   |   0.0 |  0.05
Output  | 3.709e-05  | 3.709e-05  | 3.709e-05  |   0.0 |  0.00
Modify  | 0.12097    | 0.12097    | 0.12097    |   0.0 |  0.25
Other   |            | 0.01012    |            |       |  0.02

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

Total # of neighbors = 318764
Ave neighs/atom = 79.691
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.713765637338, Press = 0.543462512833509
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11076.543     -11076.543     -11240.126     -11240.126      316.46062      316.46062      68837.995      68837.995      436.91118      436.91118    
     47000  -11072.824     -11072.824     -11237.324     -11237.324      318.23628      318.23628      68907.795      68907.795     -274.33831     -274.33831    
Loop time of 47.7404 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.810 ns/day, 13.261 hours/ns, 20.947 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    | 47.588     | 47.588     | 47.588     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021664   | 0.021664   | 0.021664   |   0.0 |  0.05
Output  | 3.0378e-05 | 3.0378e-05 | 3.0378e-05 |   0.0 |  0.00
Modify  | 0.12092    | 0.12092    | 0.12092    |   0.0 |  0.25
Other   |            | 0.01015    |            |       |  0.02

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

Total # of neighbors = 318872
Ave neighs/atom = 79.718
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.78298541301, Press = -0.41350923621731
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11072.824     -11072.824     -11237.324     -11237.324      318.23628      318.23628      68907.795      68907.795     -274.33831     -274.33831    
     48000  -11071.46      -11071.46      -11237.863     -11237.863      321.91974      321.91974      68872.726      68872.726      192.99836      192.99836    
Loop time of 47.7551 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.809 ns/day, 13.265 hours/ns, 20.940 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 47.602     | 47.602     | 47.602     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022012   | 0.022012   | 0.022012   |   0.0 |  0.05
Output  | 3.8552e-05 | 3.8552e-05 | 3.8552e-05 |   0.0 |  0.00
Modify  | 0.12092    | 0.12092    | 0.12092    |   0.0 |  0.25
Other   |            | 0.0101     |            |       |  0.02

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

Total # of neighbors = 318720
Ave neighs/atom = 79.68
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.797614736944, Press = 0.809569524116541
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11071.46      -11071.46      -11237.863     -11237.863      321.91974      321.91974      68872.726      68872.726      192.99836      192.99836    
     49000  -11077.602     -11077.602     -11241.226     -11241.226      316.54093      316.54093      68927.207      68927.207     -1016.5011     -1016.5011    
Loop time of 47.7268 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.810 ns/day, 13.257 hours/ns, 20.953 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    | 47.574     | 47.574     | 47.574     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021887   | 0.021887   | 0.021887   |   0.0 |  0.05
Output  | 3.8953e-05 | 3.8953e-05 | 3.8953e-05 |   0.0 |  0.00
Modify  | 0.12089    | 0.12089    | 0.12089    |   0.0 |  0.25
Other   |            | 0.0101     |            |       |  0.02

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

Total # of neighbors = 318802
Ave neighs/atom = 79.7005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.851836297847, Press = -0.933391116279918
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11077.602     -11077.602     -11241.226     -11241.226      316.54093      316.54093      68927.207      68927.207     -1016.5011     -1016.5011    
     50000  -11076.903     -11076.903     -11239.838     -11239.838      315.20796      315.20796      68853.939      68853.939      199.40539      199.40539    
Loop time of 47.7476 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.810 ns/day, 13.263 hours/ns, 20.943 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    | 47.595     | 47.595     | 47.595     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021985   | 0.021985   | 0.021985   |   0.0 |  0.05
Output  | 3.6749e-05 | 3.6749e-05 | 3.6749e-05 |   0.0 |  0.00
Modify  | 0.12095    | 0.12095    | 0.12095    |   0.0 |  0.25
Other   |            | 0.01008    |            |       |  0.02

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

Total # of neighbors = 318614
Ave neighs/atom = 79.6535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.854788510891, Press = 0.825250226669166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11076.903     -11076.903     -11239.838     -11239.838      315.20796      315.20796      68853.939      68853.939      199.40539      199.40539    
     51000  -11080.823     -11080.823     -11242.888     -11242.888      313.525        313.525        68891.353      68891.353     -565.86665     -565.86665    
Loop time of 47.7032 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.811 ns/day, 13.251 hours/ns, 20.963 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    | 47.55      | 47.55      | 47.55      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021936   | 0.021936   | 0.021936   |   0.0 |  0.05
Output  | 3.6379e-05 | 3.6379e-05 | 3.6379e-05 |   0.0 |  0.00
Modify  | 0.12087    | 0.12087    | 0.12087    |   0.0 |  0.25
Other   |            | 0.01012    |            |       |  0.02

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

Total # of neighbors = 318854
Ave neighs/atom = 79.7135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.8289440457, Press = -0.182602987980867
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11080.823     -11080.823     -11242.888     -11242.888      313.525        313.525        68891.353      68891.353     -565.86665     -565.86665    
     52000  -11077.454     -11077.454     -11240.643     -11240.643      315.6998       315.6998       68834.182      68834.182      524.76801      524.76801    
Loop time of 47.7159 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.811 ns/day, 13.254 hours/ns, 20.957 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    | 47.563     | 47.563     | 47.563     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02211    | 0.02211    | 0.02211    |   0.0 |  0.05
Output  | 5.4933e-05 | 5.4933e-05 | 5.4933e-05 |   0.0 |  0.00
Modify  | 0.12085    | 0.12085    | 0.12085    |   0.0 |  0.25
Other   |            | 0.0101     |            |       |  0.02

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

Total # of neighbors = 318614
Ave neighs/atom = 79.6535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.864684024943, Press = 0.409917096851137
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11077.454     -11077.454     -11240.643     -11240.643      315.6998       315.6998       68834.182      68834.182      524.76801      524.76801    
     53000  -11075.128     -11075.128     -11239.339     -11239.339      317.67726      317.67726      68942.931      68942.931     -979.6411      -979.6411     
Loop time of 47.6643 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.240 hours/ns, 20.980 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    | 47.511     | 47.511     | 47.511     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021934   | 0.021934   | 0.021934   |   0.0 |  0.05
Output  | 3.9354e-05 | 3.9354e-05 | 3.9354e-05 |   0.0 |  0.00
Modify  | 0.12087    | 0.12087    | 0.12087    |   0.0 |  0.25
Other   |            | 0.01011    |            |       |  0.02

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

Total # of neighbors = 318922
Ave neighs/atom = 79.7305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.862047218455, Press = 0.225908392778537
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11075.128     -11075.128     -11239.339     -11239.339      317.67726      317.67726      68942.931      68942.931     -979.6411      -979.6411     
     54000  -11079.809     -11079.809     -11241.083     -11241.083      311.99481      311.99481      68862.343      68862.343     -39.887124     -39.887124    
Loop time of 47.6312 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.231 hours/ns, 20.995 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    | 47.478     | 47.478     | 47.478     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021857   | 0.021857   | 0.021857   |   0.0 |  0.05
Output  | 3.8583e-05 | 3.8583e-05 | 3.8583e-05 |   0.0 |  0.00
Modify  | 0.12082    | 0.12082    | 0.12082    |   0.0 |  0.25
Other   |            | 0.01012    |            |       |  0.02

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

Total # of neighbors = 318526
Ave neighs/atom = 79.6315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.848817099251, Press = -0.61123650994838
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11079.809     -11079.809     -11241.083     -11241.083      311.99481      311.99481      68862.343      68862.343     -39.887124     -39.887124    
     55000  -11080.582     -11080.582     -11244.742     -11244.742      317.57951      317.57951      68931.714      68931.714     -1335.1399     -1335.1399    
Loop time of 47.7007 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.811 ns/day, 13.250 hours/ns, 20.964 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    | 47.548     | 47.548     | 47.548     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021923   | 0.021923   | 0.021923   |   0.0 |  0.05
Output  | 3.748e-05  | 3.748e-05  | 3.748e-05  |   0.0 |  0.00
Modify  | 0.12087    | 0.12087    | 0.12087    |   0.0 |  0.25
Other   |            | 0.01012    |            |       |  0.02

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

Total # of neighbors = 318844
Ave neighs/atom = 79.711
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.867232062764, Press = -0.402660240071011
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11080.582     -11080.582     -11244.742     -11244.742      317.57951      317.57951      68931.714      68931.714     -1335.1399     -1335.1399    
     56000  -11075.407     -11075.407     -11239.846     -11239.846      318.11847      318.11847      68917.756      68917.756     -700.72507     -700.72507    
Loop time of 47.5712 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.214 hours/ns, 21.021 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    | 47.418     | 47.418     | 47.418     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021769   | 0.021769   | 0.021769   |   0.0 |  0.05
Output  | 3.5778e-05 | 3.5778e-05 | 3.5778e-05 |   0.0 |  0.00
Modify  | 0.12091    | 0.12091    | 0.12091    |   0.0 |  0.25
Other   |            | 0.01009    |            |       |  0.02

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

Total # of neighbors = 318424
Ave neighs/atom = 79.606
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.84640365648, Press = 0.687048754881123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11075.407     -11075.407     -11239.846     -11239.846      318.11847      318.11847      68917.756      68917.756     -700.72507     -700.72507    
     57000  -11081.599     -11081.599     -11240.702     -11240.702      307.79452      307.79452      68846.623      68846.623      246.47758      246.47758    
Loop time of 47.5506 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.209 hours/ns, 21.030 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    | 47.398     | 47.398     | 47.398     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021932   | 0.021932   | 0.021932   |   0.0 |  0.05
Output  | 2.9295e-05 | 2.9295e-05 | 2.9295e-05 |   0.0 |  0.00
Modify  | 0.12085    | 0.12085    | 0.12085    |   0.0 |  0.25
Other   |            | 0.01009    |            |       |  0.02

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

Total # of neighbors = 318528
Ave neighs/atom = 79.632
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.829426349407, Press = 0.0902193691575759
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11081.599     -11081.599     -11240.702     -11240.702      307.79452      307.79452      68846.623      68846.623      246.47758      246.47758    
     58000  -11076.606     -11076.606     -11238.978     -11238.978      314.11948      314.11948      68869.624      68869.624      130.53482      130.53482    
Loop time of 47.5908 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.220 hours/ns, 21.012 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    | 47.438     | 47.438     | 47.438     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021877   | 0.021877   | 0.021877   |   0.0 |  0.05
Output  | 3.7982e-05 | 3.7982e-05 | 3.7982e-05 |   0.0 |  0.00
Modify  | 0.12084    | 0.12084    | 0.12084    |   0.0 |  0.25
Other   |            | 0.0101     |            |       |  0.02

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

Total # of neighbors = 318734
Ave neighs/atom = 79.6835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.812381532645, Press = 0.225466003646745
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11076.606     -11076.606     -11238.978     -11238.978      314.11948      314.11948      68869.624      68869.624      130.53482      130.53482    
     59000  -11082.071     -11082.071     -11243.283     -11243.283      311.87457      311.87457      68961.288      68961.288     -1633.3336     -1633.3336    
Loop time of 47.6741 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.243 hours/ns, 20.976 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    | 47.521     | 47.521     | 47.521     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021833   | 0.021833   | 0.021833   |   0.0 |  0.05
Output  | 3.7741e-05 | 3.7741e-05 | 3.7741e-05 |   0.0 |  0.00
Modify  | 0.12076    | 0.12076    | 0.12076    |   0.0 |  0.25
Other   |            | 0.01013    |            |       |  0.02

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

Total # of neighbors = 318706
Ave neighs/atom = 79.6765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.791850177797, Press = -0.372893877985583
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11082.071     -11082.071     -11243.283     -11243.283      311.87457      311.87457      68961.288      68961.288     -1633.3336     -1633.3336    
     60000  -11076.383     -11076.383     -11236.414     -11236.414      309.59186      309.59186      68820.769      68820.769      1080.9905      1080.9905    
Loop time of 47.638 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.233 hours/ns, 20.992 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    | 47.485     | 47.485     | 47.485     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021774   | 0.021774   | 0.021774   |   0.0 |  0.05
Output  | 4.7339e-05 | 4.7339e-05 | 4.7339e-05 |   0.0 |  0.00
Modify  | 0.12086    | 0.12086    | 0.12086    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318424
Ave neighs/atom = 79.606
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.81439059884, Press = 0.26515596737275
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -11076.383     -11076.383     -11236.414     -11236.414      309.59186      309.59186      68820.769      68820.769      1080.9905      1080.9905    
     61000  -11074.745     -11074.745     -11237.501     -11237.501      314.8632       314.8632       68877.87       68877.87       85.204076      85.204076    
Loop time of 47.6019 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.223 hours/ns, 21.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    | 47.449     | 47.449     | 47.449     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021714   | 0.021714   | 0.021714   |   0.0 |  0.05
Output  | 3.0087e-05 | 3.0087e-05 | 3.0087e-05 |   0.0 |  0.00
Modify  | 0.12075    | 0.12075    | 0.12075    |   0.0 |  0.25
Other   |            | 0.01015    |            |       |  0.02

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

Total # of neighbors = 318812
Ave neighs/atom = 79.703
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.825146347181, Press = 0.0616816396576282
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -11074.745     -11074.745     -11237.501     -11237.501      314.8632       314.8632       68877.87       68877.87       85.204076      85.204076    
     62000  -11078.057     -11078.057     -11238.079     -11238.079      309.57476      309.57476      68877.411      68877.411      26.611066      26.611066    
Loop time of 47.5866 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.218 hours/ns, 21.014 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    | 47.434     | 47.434     | 47.434     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02185    | 0.02185    | 0.02185    |   0.0 |  0.05
Output  | 4.3562e-05 | 4.3562e-05 | 4.3562e-05 |   0.0 |  0.00
Modify  | 0.12083    | 0.12083    | 0.12083    |   0.0 |  0.25
Other   |            | 0.0101     |            |       |  0.02

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

Total # of neighbors = 318682
Ave neighs/atom = 79.6705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.874567467556, Press = -0.0698507495827656
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -11078.057     -11078.057     -11238.079     -11238.079      309.57476      309.57476      68877.411      68877.411      26.611066      26.611066    
     63000  -11075.953     -11075.953     -11237.605     -11237.605      312.72691      312.72691      68830.098      68830.098      808.94197      808.94197    
Loop time of 47.5699 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.214 hours/ns, 21.022 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    | 47.417     | 47.417     | 47.417     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021717   | 0.021717   | 0.021717   |   0.0 |  0.05
Output  | 6.9902e-05 | 6.9902e-05 | 6.9902e-05 |   0.0 |  0.00
Modify  | 0.12096    | 0.12096    | 0.12096    |   0.0 |  0.25
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 318860
Ave neighs/atom = 79.715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.887142437593, Press = 0.116913887259551
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -11075.953     -11075.953     -11237.605     -11237.605      312.72691      312.72691      68830.098      68830.098      808.94197      808.94197    
     64000  -11080.401     -11080.401     -11241.905     -11241.905      312.43889      312.43889      68876.551      68876.551     -376.97891     -376.97891    
Loop time of 47.6726 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.242 hours/ns, 20.976 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    | 47.52      | 47.52      | 47.52      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021805   | 0.021805   | 0.021805   |   0.0 |  0.05
Output  | 4.3502e-05 | 4.3502e-05 | 4.3502e-05 |   0.0 |  0.00
Modify  | 0.12076    | 0.12076    | 0.12076    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318942
Ave neighs/atom = 79.7355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.884738404415, Press = 0.150275792872469
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -11080.401     -11080.401     -11241.905     -11241.905      312.43889      312.43889      68876.551      68876.551     -376.97891     -376.97891    
     65000  -11076.715     -11076.715     -11238.793     -11238.793      313.55148      313.55148      68842.979      68842.979      533.02207      533.02207    
Loop time of 47.6274 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.230 hours/ns, 20.996 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    | 47.475     | 47.475     | 47.475     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021776   | 0.021776   | 0.021776   |   0.0 |  0.05
Output  | 3.8632e-05 | 3.8632e-05 | 3.8632e-05 |   0.0 |  0.00
Modify  | 0.12064    | 0.12064    | 0.12064    |   0.0 |  0.25
Other   |            | 0.01015    |            |       |  0.02

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

Total # of neighbors = 318662
Ave neighs/atom = 79.6655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.879465755402, Press = -0.0429061847561413
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -11076.715     -11076.715     -11238.793     -11238.793      313.55148      313.55148      68842.979      68842.979      533.02207      533.02207    
     66000  -11082.87      -11082.87      -11241.333     -11241.333      306.55868      306.55868      68833.193      68833.193      381.55633      381.55633    
Loop time of 47.6063 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.224 hours/ns, 21.006 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    | 47.454     | 47.454     | 47.454     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021564   | 0.021564   | 0.021564   |   0.0 |  0.05
Output  | 3.0407e-05 | 3.0407e-05 | 3.0407e-05 |   0.0 |  0.00
Modify  | 0.12069    | 0.12069    | 0.12069    |   0.0 |  0.25
Other   |            | 0.01016    |            |       |  0.02

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

Total # of neighbors = 318778
Ave neighs/atom = 79.6945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.865818861269, Press = 0.522212026396584
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -11082.87      -11082.87      -11241.333     -11241.333      306.55868      306.55868      68833.193      68833.193      381.55633      381.55633    
     67000  -11077.03      -11077.03      -11238.059     -11238.059      311.52138      311.52138      68953.005      68953.005     -1142.4181     -1142.4181    
Loop time of 47.5312 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.818 ns/day, 13.203 hours/ns, 21.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    | 47.378     | 47.378     | 47.378     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021976   | 0.021976   | 0.021976   |   0.0 |  0.05
Output  | 4.3942e-05 | 4.3942e-05 | 4.3942e-05 |   0.0 |  0.00
Modify  | 0.12086    | 0.12086    | 0.12086    |   0.0 |  0.25
Other   |            | 0.01014    |            |       |  0.02

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

Total # of neighbors = 318594
Ave neighs/atom = 79.6485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.843475143602, Press = -0.234053472140087
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -11077.03      -11077.03      -11238.059     -11238.059      311.52138      311.52138      68953.005      68953.005     -1142.4181     -1142.4181    
     68000  -11079.202     -11079.202     -11242.975     -11242.975      316.83001      316.83001      68758.593      68758.593      1458.5824      1458.5824    
Loop time of 47.5207 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.818 ns/day, 13.200 hours/ns, 21.043 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    | 47.368     | 47.368     | 47.368     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021632   | 0.021632   | 0.021632   |   0.0 |  0.05
Output  | 4.9703e-05 | 4.9703e-05 | 4.9703e-05 |   0.0 |  0.00
Modify  | 0.12079    | 0.12079    | 0.12079    |   0.0 |  0.25
Other   |            | 0.01022    |            |       |  0.02

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

Total # of neighbors = 318700
Ave neighs/atom = 79.675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.828056823883, Press = 0.0411140154927573
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -11079.202     -11079.202     -11242.975     -11242.975      316.83001      316.83001      68758.593      68758.593      1458.5824      1458.5824    
     69000  -11074.886     -11074.886     -11238.901     -11238.901      317.29797      317.29797      68909.366      68909.366     -573.62476     -573.62476    
Loop time of 47.5439 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.207 hours/ns, 21.033 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    | 47.391     | 47.391     | 47.391     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021676   | 0.021676   | 0.021676   |   0.0 |  0.05
Output  | 4.9242e-05 | 4.9242e-05 | 4.9242e-05 |   0.0 |  0.00
Modify  | 0.12086    | 0.12086    | 0.12086    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318992
Ave neighs/atom = 79.748
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.809443348062, Press = 0.133131674491334
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -11074.886     -11074.886     -11238.901     -11238.901      317.29797      317.29797      68909.366      68909.366     -573.62476     -573.62476    
     70000  -11077.16      -11077.16      -11239.435     -11239.435      313.93147      313.93147      68850.312      68850.312      369.33883      369.33883    
Loop time of 47.6139 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.226 hours/ns, 21.002 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    | 47.461     | 47.461     | 47.461     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021673   | 0.021673   | 0.021673   |   0.0 |  0.05
Output  | 4.0366e-05 | 4.0366e-05 | 4.0366e-05 |   0.0 |  0.00
Modify  | 0.12078    | 0.12078    | 0.12078    |   0.0 |  0.25
Other   |            | 0.01015    |            |       |  0.02

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

Total # of neighbors = 318796
Ave neighs/atom = 79.699
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.810871116194, Press = 0.236233803034638
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -11077.16      -11077.16      -11239.435     -11239.435      313.93147      313.93147      68850.312      68850.312      369.33883      369.33883    
     71000  -11079.013     -11079.013     -11241.437     -11241.437      314.22076      314.22076      68842.955      68842.955      143.52749      143.52749    
Loop time of 47.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.212 hours/ns, 21.025 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    | 47.41      | 47.41      | 47.41      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021689   | 0.021689   | 0.021689   |   0.0 |  0.05
Output  | 3.4725e-05 | 3.4725e-05 | 3.4725e-05 |   0.0 |  0.00
Modify  | 0.12073    | 0.12073    | 0.12073    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318828
Ave neighs/atom = 79.707
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.804446608224, Press = -0.18287343077819
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -11079.013     -11079.013     -11241.437     -11241.437      314.22076      314.22076      68842.955      68842.955      143.52749      143.52749    
     72000  -11080.253     -11080.253     -11240.921     -11240.921      310.82253      310.82253      68882.435      68882.435     -339.7547      -339.7547     
Loop time of 47.5231 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.818 ns/day, 13.201 hours/ns, 21.042 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    | 47.37      | 47.37      | 47.37      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021685   | 0.021685   | 0.021685   |   0.0 |  0.05
Output  | 4.7089e-05 | 4.7089e-05 | 4.7089e-05 |   0.0 |  0.00
Modify  | 0.12082    | 0.12082    | 0.12082    |   0.0 |  0.25
Other   |            | 0.01017    |            |       |  0.02

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

Total # of neighbors = 318894
Ave neighs/atom = 79.7235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.798460048779, Press = -0.33755758075104
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -11080.253     -11080.253     -11240.921     -11240.921      310.82253      310.82253      68882.435      68882.435     -339.7547      -339.7547     
     73000  -11076.181     -11076.181     -11240.197     -11240.197      317.29932      317.29932      68817.864      68817.864      851.08185      851.08185    
Loop time of 47.635 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.232 hours/ns, 20.993 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    | 47.482     | 47.482     | 47.482     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021733   | 0.021733   | 0.021733   |   0.0 |  0.05
Output  | 4.1167e-05 | 4.1167e-05 | 4.1167e-05 |   0.0 |  0.00
Modify  | 0.12075    | 0.12075    | 0.12075    |   0.0 |  0.25
Other   |            | 0.01013    |            |       |  0.02

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

Total # of neighbors = 318748
Ave neighs/atom = 79.687
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.813345433528, Press = 0.139881059347537
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -11076.181     -11076.181     -11240.197     -11240.197      317.29932      317.29932      68817.864      68817.864      851.08185      851.08185    
     74000  -11082.415     -11082.415     -11239.934     -11239.934      304.73168      304.73168      68931.084      68931.084     -939.29366     -939.29366    
Loop time of 47.6934 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.248 hours/ns, 20.967 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    | 47.541     | 47.541     | 47.541     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021877   | 0.021877   | 0.021877   |   0.0 |  0.05
Output  | 4.1207e-05 | 4.1207e-05 | 4.1207e-05 |   0.0 |  0.00
Modify  | 0.12082    | 0.12082    | 0.12082    |   0.0 |  0.25
Other   |            | 0.01012    |            |       |  0.02

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

Total # of neighbors = 319004
Ave neighs/atom = 79.751
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.781012590025, Press = 0.246673888416847
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -11082.415     -11082.415     -11239.934     -11239.934      304.73168      304.73168      68931.084      68931.084     -939.29366     -939.29366    
     75000  -11079.428     -11079.428     -11241.071     -11241.071      312.70944      312.70944      68746.881      68746.881      1746.089       1746.089     
Loop time of 47.6833 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.245 hours/ns, 20.972 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    | 47.531     | 47.531     | 47.531     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021799   | 0.021799   | 0.021799   |   0.0 |  0.05
Output  | 3.8463e-05 | 3.8463e-05 | 3.8463e-05 |   0.0 |  0.00
Modify  | 0.12075    | 0.12075    | 0.12075    |   0.0 |  0.25
Other   |            | 0.01011    |            |       |  0.02

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

Total # of neighbors = 318544
Ave neighs/atom = 79.636
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.790949658182, Press = -0.0642896153290348
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -11079.428     -11079.428     -11241.071     -11241.071      312.70944      312.70944      68746.881      68746.881      1746.089       1746.089     
     76000  -11075.386     -11075.386     -11237.021     -11237.021      312.69364      312.69364      68918.631      68918.631     -394.52876     -394.52876    
Loop time of 47.6401 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.233 hours/ns, 20.991 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    | 47.487     | 47.487     | 47.487     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021646   | 0.021646   | 0.021646   |   0.0 |  0.05
Output  | 2.8363e-05 | 2.8363e-05 | 2.8363e-05 |   0.0 |  0.00
Modify  | 0.12076    | 0.12076    | 0.12076    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318978
Ave neighs/atom = 79.7445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.811517543784, Press = 0.0400583645933503
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -11075.386     -11075.386     -11237.021     -11237.021      312.69364      312.69364      68918.631      68918.631     -394.52876     -394.52876    
     77000  -11079.79      -11079.79      -11240.457     -11240.457      310.82108      310.82108      68894.303      68894.303     -394.97956     -394.97956    
Loop time of 47.5707 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.214 hours/ns, 21.021 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    | 47.418     | 47.418     | 47.418     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021655   | 0.021655   | 0.021655   |   0.0 |  0.05
Output  | 3.8623e-05 | 3.8623e-05 | 3.8623e-05 |   0.0 |  0.00
Modify  | 0.1207     | 0.1207     | 0.1207     |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318564
Ave neighs/atom = 79.641
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.814727573484, Press = -0.655840686493953
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     77000  -11079.79      -11079.79      -11240.457     -11240.457      310.82108      310.82108      68894.303      68894.303     -394.97956     -394.97956    
     78000  -11077.203     -11077.203     -11236.851     -11236.851      308.85028      308.85028      68848.786      68848.786      606.00471      606.00471    
Loop time of 47.6191 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.228 hours/ns, 21.000 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    | 47.466     | 47.466     | 47.466     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021657   | 0.021657   | 0.021657   |   0.0 |  0.05
Output  | 4.1949e-05 | 4.1949e-05 | 4.1949e-05 |   0.0 |  0.00
Modify  | 0.12074    | 0.12074    | 0.12074    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318764
Ave neighs/atom = 79.691
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.823670620845, Press = 0.614033158909747
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     78000  -11077.203     -11077.203     -11236.851     -11236.851      308.85028      308.85028      68848.786      68848.786      606.00471      606.00471    
     79000  -11076.934     -11076.934     -11239.136     -11239.136      313.79051      313.79051      68853.95       68853.95       418.61218      418.61218    
Loop time of 47.6409 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.234 hours/ns, 20.990 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    | 47.488     | 47.488     | 47.488     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02166    | 0.02166    | 0.02166    |   0.0 |  0.05
Output  | 3.724e-05  | 3.724e-05  | 3.724e-05  |   0.0 |  0.00
Modify  | 0.12074    | 0.12074    | 0.12074    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318868
Ave neighs/atom = 79.717
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.822408001244, Press = -0.0851258053467092
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     79000  -11076.934     -11076.934     -11239.136     -11239.136      313.79051      313.79051      68853.95       68853.95       418.61218      418.61218    
     80000  -11076.496     -11076.496     -11234.836     -11234.836      306.32018      306.32018      68849.942      68849.942      824.99023      824.99023    
Loop time of 47.6433 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.234 hours/ns, 20.989 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    | 47.491     | 47.491     | 47.491     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021612   | 0.021612   | 0.021612   |   0.0 |  0.05
Output  | 3.5056e-05 | 3.5056e-05 | 3.5056e-05 |   0.0 |  0.00
Modify  | 0.12059    | 0.12059    | 0.12059    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318826
Ave neighs/atom = 79.7065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.85499939656, Press = 0.52973353990265
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     80000  -11076.496     -11076.496     -11234.836     -11234.836      306.32018      306.32018      68849.942      68849.942      824.99023      824.99023    
     81000  -11076.938     -11076.938     -11240.35      -11240.35       316.13219      316.13219      68916.535      68916.535     -704.79055     -704.79055    
Loop time of 47.6529 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.237 hours/ns, 20.985 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    | 47.5       | 47.5       | 47.5       |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021718   | 0.021718   | 0.021718   |   0.0 |  0.05
Output  | 3.0097e-05 | 3.0097e-05 | 3.0097e-05 |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.25
Other   |            | 0.01016    |            |       |  0.02

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

Total # of neighbors = 318786
Ave neighs/atom = 79.6965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.859548549563, Press = -0.186382991518256
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     81000  -11076.938     -11076.938     -11240.35      -11240.35       316.13219      316.13219      68916.535      68916.535     -704.79055     -704.79055    
     82000  -11080.119     -11080.119     -11241.192     -11241.192      311.60747      311.60747      68892.022      68892.022     -350.25058     -350.25058    
Loop time of 47.654 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.237 hours/ns, 20.985 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    | 47.501     | 47.501     | 47.501     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021846   | 0.021846   | 0.021846   |   0.0 |  0.05
Output  | 3.72e-05   | 3.72e-05   | 3.72e-05   |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.25
Other   |            | 0.0101     |            |       |  0.02

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

Total # of neighbors = 318700
Ave neighs/atom = 79.675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.854935298271, Press = 0.323817272601339
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     82000  -11080.119     -11080.119     -11241.192     -11241.192      311.60747      311.60747      68892.022      68892.022     -350.25058     -350.25058    
     83000  -11081.255     -11081.255     -11241.41      -11241.41       309.8305       309.8305       68908.341      68908.341     -757.7099      -757.7099     
Loop time of 47.5509 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.209 hours/ns, 21.030 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    | 47.398     | 47.398     | 47.398     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02178    | 0.02178    | 0.02178    |   0.0 |  0.05
Output  | 3.9234e-05 | 3.9234e-05 | 3.9234e-05 |   0.0 |  0.00
Modify  | 0.12071    | 0.12071    | 0.12071    |   0.0 |  0.25
Other   |            | 0.0101     |            |       |  0.02

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

Total # of neighbors = 318590
Ave neighs/atom = 79.6475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.840780540521, Press = 0.153249586775559
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     83000  -11081.255     -11081.255     -11241.41      -11241.41       309.8305       309.8305       68908.341      68908.341     -757.7099      -757.7099     
     84000  -11075.251     -11075.251     -11238.27      -11238.27       315.37185      315.37185      68896.996      68896.996     -199.03455     -199.03455    
Loop time of 47.5837 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.218 hours/ns, 21.016 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    | 47.431     | 47.431     | 47.431     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021795   | 0.021795   | 0.021795   |   0.0 |  0.05
Output  | 3.8943e-05 | 3.8943e-05 | 3.8943e-05 |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318646
Ave neighs/atom = 79.6615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.83229821298, Press = 0.00747759932322071
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     84000  -11075.251     -11075.251     -11238.27      -11238.27       315.37185      315.37185      68896.996      68896.996     -199.03455     -199.03455    
     85000  -11079.414     -11079.414     -11239.144     -11239.144      309.00785      309.00785      68836.002      68836.002      496.34808      496.34808    
Loop time of 47.5977 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.222 hours/ns, 21.009 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    | 47.445     | 47.445     | 47.445     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021836   | 0.021836   | 0.021836   |   0.0 |  0.05
Output  | 4.1488e-05 | 4.1488e-05 | 4.1488e-05 |   0.0 |  0.00
Modify  | 0.12084    | 0.12084    | 0.12084    |   0.0 |  0.25
Other   |            | 0.01014    |            |       |  0.02

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

Total # of neighbors = 318706
Ave neighs/atom = 79.6765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.831457649466, Press = 0.0250140866268882
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     85000  -11079.414     -11079.414     -11239.144     -11239.144      309.00785      309.00785      68836.002      68836.002      496.34808      496.34808    
     86000  -11082.093     -11082.093     -11243.834     -11243.834      312.89917      312.89917      68906.199      68906.199     -915.80902     -915.80902    
Loop time of 47.6843 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.246 hours/ns, 20.971 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    | 47.532     | 47.532     | 47.532     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021779   | 0.021779   | 0.021779   |   0.0 |  0.05
Output  | 3.4876e-05 | 3.4876e-05 | 3.4876e-05 |   0.0 |  0.00
Modify  | 0.12075    | 0.12075    | 0.12075    |   0.0 |  0.25
Other   |            | 0.01011    |            |       |  0.02

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

Total # of neighbors = 318876
Ave neighs/atom = 79.719
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.840358947147, Press = -0.287466127602841
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     86000  -11082.093     -11082.093     -11243.834     -11243.834      312.89917      312.89917      68906.199      68906.199     -915.80902     -915.80902    
     87000  -11076.736     -11076.736     -11237.932     -11237.932      311.84345      311.84345      68784.471      68784.471      1450.8222      1450.8222    
Loop time of 47.5975 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.222 hours/ns, 21.009 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    | 47.445     | 47.445     | 47.445     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02176    | 0.02176    | 0.02176    |   0.0 |  0.05
Output  | 4.5976e-05 | 4.5976e-05 | 4.5976e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.25
Other   |            | 0.01015    |            |       |  0.02

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

Total # of neighbors = 318720
Ave neighs/atom = 79.68
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.82213273408, Press = 0.351217696340676
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     87000  -11076.736     -11076.736     -11237.932     -11237.932      311.84345      311.84345      68784.471      68784.471      1450.8222      1450.8222    
     88000  -11076.731     -11076.731     -11238.428     -11238.428      312.81385      312.81385      68959.073      68959.073     -1192.6729     -1192.6729    
Loop time of 47.6065 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.224 hours/ns, 21.006 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    | 47.454     | 47.454     | 47.454     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021794   | 0.021794   | 0.021794   |   0.0 |  0.05
Output  | 4.7289e-05 | 4.7289e-05 | 4.7289e-05 |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.25
Other   |            | 0.01016    |            |       |  0.02

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

Total # of neighbors = 319026
Ave neighs/atom = 79.7565
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.82108961853, Press = -0.097436871431728
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     88000  -11076.731     -11076.731     -11238.428     -11238.428      312.81385      312.81385      68959.073      68959.073     -1192.6729     -1192.6729    
     89000  -11077.896     -11077.896     -11240.078     -11240.078      313.7512       313.7512       68820.522      68820.522      755.26177      755.26177    
Loop time of 47.6222 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.228 hours/ns, 20.999 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    | 47.47      | 47.47      | 47.47      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021653   | 0.021653   | 0.021653   |   0.0 |  0.05
Output  | 4.2761e-05 | 4.2761e-05 | 4.2761e-05 |   0.0 |  0.00
Modify  | 0.12074    | 0.12074    | 0.12074    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318616
Ave neighs/atom = 79.654
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.820929551653, Press = 0.221917277275763
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     89000  -11077.896     -11077.896     -11240.078     -11240.078      313.7512       313.7512       68820.522      68820.522      755.26177      755.26177    
     90000  -11074.521     -11074.521     -11237.774     -11237.774      315.8231       315.8231       68945.187      68945.187     -966.51034     -966.51034    
Loop time of 47.6013 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.223 hours/ns, 21.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    | 47.449     | 47.449     | 47.449     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021696   | 0.021696   | 0.021696   |   0.0 |  0.05
Output  | 7.7887e-05 | 7.7887e-05 | 7.7887e-05 |   0.0 |  0.00
Modify  | 0.12071    | 0.12071    | 0.12071    |   0.0 |  0.25
Other   |            | 0.01009    |            |       |  0.02

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

Total # of neighbors = 318824
Ave neighs/atom = 79.706
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.830114052298, Press = 0.129701617555867
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     90000  -11074.521     -11074.521     -11237.774     -11237.774      315.8231       315.8231       68945.187      68945.187     -966.51034     -966.51034    
     91000  -11080.079     -11080.079     -11240.944     -11240.944      311.2032       311.2032       68824.663      68824.663      534.88821      534.88821    
Loop time of 47.6257 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.229 hours/ns, 20.997 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    | 47.473     | 47.473     | 47.473     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021826   | 0.021826   | 0.021826   |   0.0 |  0.05
Output  | 4.1789e-05 | 4.1789e-05 | 4.1789e-05 |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.25
Other   |            | 0.01014    |            |       |  0.02

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

Total # of neighbors = 318744
Ave neighs/atom = 79.686
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.850240007048, Press = -0.0440739016423045
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     91000  -11080.079     -11080.079     -11240.944     -11240.944      311.2032       311.2032       68824.663      68824.663      534.88821      534.88821    
     92000  -11072.03      -11072.03      -11234.535     -11234.535      314.37596      314.37596      68956.137      68956.137     -779.409       -779.409      
Loop time of 47.6325 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.231 hours/ns, 20.994 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    | 47.48      | 47.48      | 47.48      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021848   | 0.021848   | 0.021848   |   0.0 |  0.05
Output  | 4.0346e-05 | 4.0346e-05 | 4.0346e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.25
Other   |            | 0.01011    |            |       |  0.02

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

Total # of neighbors = 318876
Ave neighs/atom = 79.719
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.857386027581, Press = 0.111409273718662
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     92000  -11072.03      -11072.03      -11234.535     -11234.535      314.37596      314.37596      68956.137      68956.137     -779.409       -779.409      
     93000  -11079.717     -11079.717     -11240.945     -11240.945      311.90543      311.90543      68790.33       68790.33       1122.1996      1122.1996    
Loop time of 47.4901 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.819 ns/day, 13.192 hours/ns, 21.057 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    | 47.337     | 47.337     | 47.337     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021683   | 0.021683   | 0.021683   |   0.0 |  0.05
Output  | 5.7609e-05 | 5.7609e-05 | 5.7609e-05 |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318606
Ave neighs/atom = 79.6515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.876926230324, Press = -0.107049383242898
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     93000  -11079.717     -11079.717     -11240.945     -11240.945      311.90543      311.90543      68790.33       68790.33       1122.1996      1122.1996    
     94000  -11081.519     -11081.519     -11240.026     -11240.026      306.64288      306.64288      68942.68       68942.68      -1167.1473     -1167.1473    
Loop time of 47.5233 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.818 ns/day, 13.201 hours/ns, 21.042 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    | 47.371     | 47.371     | 47.371     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021672   | 0.021672   | 0.021672   |   0.0 |  0.05
Output  | 5.3841e-05 | 5.3841e-05 | 5.3841e-05 |   0.0 |  0.00
Modify  | 0.12076    | 0.12076    | 0.12076    |   0.0 |  0.25
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 318832
Ave neighs/atom = 79.708
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.885867262223, Press = 0.357173379786333
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     94000  -11081.519     -11081.519     -11240.026     -11240.026      306.64288      306.64288      68942.68       68942.68      -1167.1473     -1167.1473    
     95000  -11077.091     -11077.091     -11239.879     -11239.879      314.92566      314.92566      68858.991      68858.991      201.53627      201.53627    
Loop time of 47.4449 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.821 ns/day, 13.179 hours/ns, 21.077 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    | 47.292     | 47.292     | 47.292     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021668   | 0.021668   | 0.021668   |   0.0 |  0.05
Output  | 3.9224e-05 | 3.9224e-05 | 3.9224e-05 |   0.0 |  0.00
Modify  | 0.12054    | 0.12054    | 0.12054    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318608
Ave neighs/atom = 79.652
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.878533886062, Press = -0.355938423016008
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     95000  -11077.091     -11077.091     -11239.879     -11239.879      314.92566      314.92566      68858.991      68858.991      201.53627      201.53627    
     96000  -11082.908     -11082.908     -11242.348     -11242.348      308.44688      308.44688      68840.011      68840.011      188.59972      188.59972    
Loop time of 47.5047 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.819 ns/day, 13.196 hours/ns, 21.051 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    | 47.352     | 47.352     | 47.352     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021658   | 0.021658   | 0.021658   |   0.0 |  0.05
Output  | 4.1398e-05 | 4.1398e-05 | 4.1398e-05 |   0.0 |  0.00
Modify  | 0.12059    | 0.12059    | 0.12059    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318736
Ave neighs/atom = 79.684
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.875311378544, Press = 0.783940666118237
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     96000  -11082.908     -11082.908     -11242.348     -11242.348      308.44688      308.44688      68840.011      68840.011      188.59972      188.59972    
     97000  -11075.846     -11075.846     -11239.119     -11239.119      315.86205      315.86205      68906.311      68906.311     -435.79763     -435.79763    
Loop time of 47.5317 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.818 ns/day, 13.203 hours/ns, 21.039 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    | 47.379     | 47.379     | 47.379     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021663   | 0.021663   | 0.021663   |   0.0 |  0.05
Output  | 4.0216e-05 | 4.0216e-05 | 4.0216e-05 |   0.0 |  0.00
Modify  | 0.12059    | 0.12059    | 0.12059    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318712
Ave neighs/atom = 79.678
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.856308712335, Press = -0.593732853517908
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     97000  -11075.846     -11075.846     -11239.119     -11239.119      315.86205      315.86205      68906.311      68906.311     -435.79763     -435.79763    
     98000  -11079.956     -11079.956     -11241.306     -11241.306      312.14133      312.14133      68849.167      68849.167      149.58722      149.58722    
Loop time of 47.6876 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.247 hours/ns, 20.970 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    | 47.535     | 47.535     | 47.535     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02181    | 0.02181    | 0.02181    |   0.0 |  0.05
Output  | 3.8492e-05 | 3.8492e-05 | 3.8492e-05 |   0.0 |  0.00
Modify  | 0.12064    | 0.12064    | 0.12064    |   0.0 |  0.25
Other   |            | 0.0101     |            |       |  0.02

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

Total # of neighbors = 318694
Ave neighs/atom = 79.6735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.842531436334, Press = 0.45791818006857
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     98000  -11079.956     -11079.956     -11241.306     -11241.306      312.14133      312.14133      68849.167      68849.167      149.58722      149.58722    
     99000  -11076.096     -11076.096     -11239.785     -11239.785      316.66716      316.66716      68813.736      68813.736      897.91724      897.91724    
Loop time of 47.5663 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.213 hours/ns, 21.023 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    | 47.413     | 47.413     | 47.413     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021943   | 0.021943   | 0.021943   |   0.0 |  0.05
Output  | 3.709e-05  | 3.709e-05  | 3.709e-05  |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.25
Other   |            | 0.01012    |            |       |  0.02

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

Total # of neighbors = 318818
Ave neighs/atom = 79.7045
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.825833785032, Press = -0.0300362141131692
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     99000  -11076.096     -11076.096     -11239.785     -11239.785      316.66716      316.66716      68813.736      68813.736      897.91724      897.91724    
    100000  -11078.461     -11078.461     -11239.41      -11239.41       311.36555      311.36555      68891.765      68891.765     -374.0507      -374.0507     
Loop time of 47.5924 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.220 hours/ns, 21.012 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    | 47.44      | 47.44      | 47.44      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021747   | 0.021747   | 0.021747   |   0.0 |  0.05
Output  | 2.9616e-05 | 2.9616e-05 | 2.9616e-05 |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318894
Ave neighs/atom = 79.7235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.829158433258, Press = 0.339738191031692
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    100000  -11078.461     -11078.461     -11239.41      -11239.41       311.36555      311.36555      68891.765      68891.765     -374.0507      -374.0507     
    101000  -11080.972     -11080.972     -11241.045     -11241.045      309.67184      309.67184      68817.834      68817.834      666.27082      666.27082    
Loop time of 47.6196 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.228 hours/ns, 21.000 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    | 47.467     | 47.467     | 47.467     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02168    | 0.02168    | 0.02168    |   0.0 |  0.05
Output  | 3.9675e-05 | 3.9675e-05 | 3.9675e-05 |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318612
Ave neighs/atom = 79.653
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.830176814677, Press = -0.112307405575065
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    101000  -11080.972     -11080.972     -11241.045     -11241.045      309.67184      309.67184      68817.834      68817.834      666.27082      666.27082    
    102000  -11076.255     -11076.255     -11238.135     -11238.135      313.16803      313.16803      68945.386      68945.386     -955.82197     -955.82197    
Loop time of 47.582 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.217 hours/ns, 21.016 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    | 47.429     | 47.429     | 47.429     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021608   | 0.021608   | 0.021608   |   0.0 |  0.05
Output  | 3.8031e-05 | 3.8031e-05 | 3.8031e-05 |   0.0 |  0.00
Modify  | 0.12076    | 0.12076    | 0.12076    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318844
Ave neighs/atom = 79.711
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.844139241038, Press = 0.131130009600062
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    102000  -11076.255     -11076.255     -11238.135     -11238.135      313.16803      313.16803      68945.386      68945.386     -955.82197     -955.82197    
    103000  -11077.802     -11077.802     -11240.222     -11240.222      314.21192      314.21192      68839.058      68839.058      400.73863      400.73863    
Loop time of 47.6179 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.227 hours/ns, 21.000 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    | 47.465     | 47.465     | 47.465     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02189    | 0.02189    | 0.02189    |   0.0 |  0.05
Output  | 3.7541e-05 | 3.7541e-05 | 3.7541e-05 |   0.0 |  0.00
Modify  | 0.12077    | 0.12077    | 0.12077    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318620
Ave neighs/atom = 79.655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.844572740969, Press = -0.0890533358194694
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    103000  -11077.802     -11077.802     -11240.222     -11240.222      314.21192      314.21192      68839.058      68839.058      400.73863      400.73863    
    104000  -11073.186     -11073.186     -11235.906     -11235.906      314.79258      314.79258      68871.935      68871.935      315.85781      315.85781    
Loop time of 47.6875 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.247 hours/ns, 20.970 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    | 47.535     | 47.535     | 47.535     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021717   | 0.021717   | 0.021717   |   0.0 |  0.05
Output  | 3.9123e-05 | 3.9123e-05 | 3.9123e-05 |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318788
Ave neighs/atom = 79.697
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.855802157945, Press = 0.173816306079968
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    104000  -11073.186     -11073.186     -11235.906     -11235.906      314.79258      314.79258      68871.935      68871.935      315.85781      315.85781    
    105000  -11079.525     -11079.525     -11239.171     -11239.171      308.84572      308.84572      68827.806      68827.806      617.01075      617.01075    
Loop time of 47.5697 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.214 hours/ns, 21.022 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    | 47.417     | 47.417     | 47.417     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021897   | 0.021897   | 0.021897   |   0.0 |  0.05
Output  | 2.9886e-05 | 2.9886e-05 | 2.9886e-05 |   0.0 |  0.00
Modify  | 0.12068    | 0.12068    | 0.12068    |   0.0 |  0.25
Other   |            | 0.01017    |            |       |  0.02

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

Total # of neighbors = 319008
Ave neighs/atom = 79.752
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.874330866654, Press = 0.148051032520734
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    105000  -11079.525     -11079.525     -11239.171     -11239.171      308.84572      308.84572      68827.806      68827.806      617.01075      617.01075    
    106000  -11074.489     -11074.489     -11236.268     -11236.268      312.97361      312.97361      68992.858      68992.858     -1548.2446     -1548.2446    
Loop time of 47.6133 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.226 hours/ns, 21.003 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    | 47.461     | 47.461     | 47.461     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021642   | 0.021642   | 0.021642   |   0.0 |  0.05
Output  | 3.7821e-05 | 3.7821e-05 | 3.7821e-05 |   0.0 |  0.00
Modify  | 0.12075    | 0.12075    | 0.12075    |   0.0 |  0.25
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 318962
Ave neighs/atom = 79.7405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.89371720692, Press = -0.632683595580395
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    106000  -11074.489     -11074.489     -11236.268     -11236.268      312.97361      312.97361      68992.858      68992.858     -1548.2446     -1548.2446    
    107000  -11079.075     -11079.075     -11240.809     -11240.809      312.88493      312.88493      68786.584      68786.584      1259.5581      1259.5581    
Loop time of 47.5471 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.208 hours/ns, 21.032 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    | 47.394     | 47.394     | 47.394     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021758   | 0.021758   | 0.021758   |   0.0 |  0.05
Output  | 3.7461e-05 | 3.7461e-05 | 3.7461e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318538
Ave neighs/atom = 79.6345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.880422183436, Press = 0.210333280922826
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    107000  -11079.075     -11079.075     -11240.809     -11240.809      312.88493      312.88493      68786.584      68786.584      1259.5581      1259.5581    
    108000  -11075.982     -11075.982     -11236.658     -11236.658      310.83951      310.83951      68978.78       68978.78      -1289.6866     -1289.6866    
Loop time of 47.6019 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.223 hours/ns, 21.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    | 47.449     | 47.449     | 47.449     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02168    | 0.02168    | 0.02168    |   0.0 |  0.05
Output  | 3.7862e-05 | 3.7862e-05 | 3.7862e-05 |   0.0 |  0.00
Modify  | 0.12075    | 0.12075    | 0.12075    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318864
Ave neighs/atom = 79.716
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.866819813469, Press = 0.162651934071666
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    108000  -11075.982     -11075.982     -11236.658     -11236.658      310.83951      310.83951      68978.78       68978.78      -1289.6866     -1289.6866    
    109000  -11079.976     -11079.976     -11241.34      -11241.34       312.16885      312.16885      68798.22       68798.22       947.37649      947.37649    
Loop time of 47.5826 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.217 hours/ns, 21.016 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    | 47.43      | 47.43      | 47.43      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021694   | 0.021694   | 0.021694   |   0.0 |  0.05
Output  | 3.5227e-05 | 3.5227e-05 | 3.5227e-05 |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318494
Ave neighs/atom = 79.6235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.863134998576, Press = -0.00158124526393068
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    109000  -11079.976     -11079.976     -11241.34      -11241.34       312.16885      312.16885      68798.22       68798.22       947.37649      947.37649    
    110000  -11080.799     -11080.799     -11239.454     -11239.454      306.93006      306.93006      68892.908      68892.908     -331.51372     -331.51372    
Loop time of 47.5923 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.220 hours/ns, 21.012 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    | 47.44      | 47.44      | 47.44      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021694   | 0.021694   | 0.021694   |   0.0 |  0.05
Output  | 3.4886e-05 | 3.4886e-05 | 3.4886e-05 |   0.0 |  0.00
Modify  | 0.12067    | 0.12067    | 0.12067    |   0.0 |  0.25
Other   |            | 0.01017    |            |       |  0.02

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

Total # of neighbors = 318826
Ave neighs/atom = 79.7065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.868491742778, Press = 0.0691755379196854
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    110000  -11080.799     -11080.799     -11239.454     -11239.454      306.93006      306.93006      68892.908      68892.908     -331.51372     -331.51372    
    111000  -11073.338     -11073.338     -11239.578     -11239.578      321.60234      321.60234      68882.344      68882.344      4.690415       4.690415     
Loop time of 47.6074 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.224 hours/ns, 21.005 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    | 47.455     | 47.455     | 47.455     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02171    | 0.02171    | 0.02171    |   0.0 |  0.05
Output  | 4.1088e-05 | 4.1088e-05 | 4.1088e-05 |   0.0 |  0.00
Modify  | 0.12074    | 0.12074    | 0.12074    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318688
Ave neighs/atom = 79.672
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.866262579222, Press = -0.208899393117036
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    111000  -11073.338     -11073.338     -11239.578     -11239.578      321.60234      321.60234      68882.344      68882.344      4.690415       4.690415     
    112000  -11075.032     -11075.032     -11239.509     -11239.509      318.19199      318.19199      68913.158      68913.158     -560.94372     -560.94372    
Loop time of 47.5339 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.818 ns/day, 13.204 hours/ns, 21.038 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    | 47.381     | 47.381     | 47.381     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021716   | 0.021716   | 0.021716   |   0.0 |  0.05
Output  | 3.7521e-05 | 3.7521e-05 | 3.7521e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318748
Ave neighs/atom = 79.687
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.860069721373, Press = -0.00875084495361155
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    112000  -11075.032     -11075.032     -11239.509     -11239.509      318.19199      318.19199      68913.158      68913.158     -560.94372     -560.94372    
    113000  -11077.308     -11077.308     -11238.036     -11238.036      310.93926      310.93926      68831.349      68831.349      759.77522      759.77522    
Loop time of 47.5921 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.220 hours/ns, 21.012 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    | 47.439     | 47.439     | 47.439     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0217     | 0.0217     | 0.0217     |   0.0 |  0.05
Output  | 3.6509e-05 | 3.6509e-05 | 3.6509e-05 |   0.0 |  0.00
Modify  | 0.12073    | 0.12073    | 0.12073    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318710
Ave neighs/atom = 79.6775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.85882719123, Press = 0.239381396525128
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    113000  -11077.308     -11077.308     -11238.036     -11238.036      310.93926      310.93926      68831.349      68831.349      759.77522      759.77522    
    114000  -11083.405     -11083.405     -11242.597     -11242.597      307.96726      307.96726      68910.841      68910.841     -951.41532     -951.41532    
Loop time of 47.5533 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.209 hours/ns, 21.029 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    | 47.401     | 47.401     | 47.401     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021741   | 0.021741   | 0.021741   |   0.0 |  0.05
Output  | 2.9606e-05 | 2.9606e-05 | 2.9606e-05 |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.25
Other   |            | 0.01015    |            |       |  0.02

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

Total # of neighbors = 318878
Ave neighs/atom = 79.7195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.840808762123, Press = -0.222298482906555
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    114000  -11083.405     -11083.405     -11242.597     -11242.597      307.96726      307.96726      68910.841      68910.841     -951.41532     -951.41532    
    115000  -11075.447     -11075.447     -11237.398     -11237.398      313.30547      313.30547      68846.319      68846.319      559.32161      559.32161    
Loop time of 47.5432 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.206 hours/ns, 21.034 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    | 47.39      | 47.39      | 47.39      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021853   | 0.021853   | 0.021853   |   0.0 |  0.05
Output  | 3.7019e-05 | 3.7019e-05 | 3.7019e-05 |   0.0 |  0.00
Modify  | 0.12083    | 0.12083    | 0.12083    |   0.0 |  0.25
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 318510
Ave neighs/atom = 79.6275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.828324739871, Press = 0.136807324364817
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    115000  -11075.447     -11075.447     -11237.398     -11237.398      313.30547      313.30547      68846.319      68846.319      559.32161      559.32161    
    116000  -11077.472     -11077.472     -11240.183     -11240.183      314.77611      314.77611      68876.818      68876.818     -113.19302     -113.19302    
Loop time of 47.5689 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.214 hours/ns, 21.022 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    | 47.416     | 47.416     | 47.416     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02182    | 0.02182    | 0.02182    |   0.0 |  0.05
Output  | 3.693e-05  | 3.693e-05  | 3.693e-05  |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318930
Ave neighs/atom = 79.7325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.826888990369, Press = -0.24931033637426
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    116000  -11077.472     -11077.472     -11240.183     -11240.183      314.77611      314.77611      68876.818      68876.818     -113.19302     -113.19302    
    117000  -11076.447     -11076.447     -11238.84      -11238.84       314.15849      314.15849      68865.793      68865.793      120.49984      120.49984    
Loop time of 47.5218 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.818 ns/day, 13.200 hours/ns, 21.043 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    | 47.369     | 47.369     | 47.369     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021768   | 0.021768   | 0.021768   |   0.0 |  0.05
Output  | 3.6218e-05 | 3.6218e-05 | 3.6218e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318672
Ave neighs/atom = 79.668
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.830461013235, Press = 0.256064446966676
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    117000  -11076.447     -11076.447     -11238.84      -11238.84       314.15849      314.15849      68865.793      68865.793      120.49984      120.49984    
    118000  -11076.216     -11076.216     -11237.882     -11237.882      312.75365      312.75365      68905.139      68905.139     -426.87546     -426.87546    
Loop time of 47.5967 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.221 hours/ns, 21.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    | 47.444     | 47.444     | 47.444     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021676   | 0.021676   | 0.021676   |   0.0 |  0.05
Output  | 3.6469e-05 | 3.6469e-05 | 3.6469e-05 |   0.0 |  0.00
Modify  | 0.12079    | 0.12079    | 0.12079    |   0.0 |  0.25
Other   |            | 0.01017    |            |       |  0.02

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

Total # of neighbors = 318802
Ave neighs/atom = 79.7005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.848102336932, Press = -0.0208491239866028
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    118000  -11076.216     -11076.216     -11237.882     -11237.882      312.75365      312.75365      68905.139      68905.139     -426.87546     -426.87546    
    119000  -11076.482     -11076.482     -11238.742     -11238.742      313.90223      313.90223      68825.85       68825.85       811.77477      811.77477    
Loop time of 47.4398 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.821 ns/day, 13.178 hours/ns, 21.079 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    | 47.287     | 47.287     | 47.287     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021629   | 0.021629   | 0.021629   |   0.0 |  0.05
Output  | 2.8584e-05 | 2.8584e-05 | 2.8584e-05 |   0.0 |  0.00
Modify  | 0.12073    | 0.12073    | 0.12073    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318732
Ave neighs/atom = 79.683
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.839493399194, Press = 0.180953860239658
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    119000  -11076.482     -11076.482     -11238.742     -11238.742      313.90223      313.90223      68825.85       68825.85       811.77477      811.77477    
    120000  -11080.94      -11080.94      -11238.052     -11238.052      303.94451      303.94451      68926.318      68926.318     -786.84973     -786.84973    
Loop time of 47.5446 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.207 hours/ns, 21.033 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    | 47.392     | 47.392     | 47.392     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021699   | 0.021699   | 0.021699   |   0.0 |  0.05
Output  | 3.7641e-05 | 3.7641e-05 | 3.7641e-05 |   0.0 |  0.00
Modify  | 0.12076    | 0.12076    | 0.12076    |   0.0 |  0.25
Other   |            | 0.01016    |            |       |  0.02

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

Total # of neighbors = 318820
Ave neighs/atom = 79.705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.840539150069, Press = -0.322852676403114
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    120000  -11080.94      -11080.94      -11238.052     -11238.052      303.94451      303.94451      68926.318      68926.318     -786.84973     -786.84973    
    121000  -11075.367     -11075.367     -11237.702     -11237.702      314.04831      314.04831      68795.381      68795.381      1349.15        1349.15      
Loop time of 47.525 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.818 ns/day, 13.201 hours/ns, 21.042 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    | 47.372     | 47.372     | 47.372     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021809   | 0.021809   | 0.021809   |   0.0 |  0.05
Output  | 3.8823e-05 | 3.8823e-05 | 3.8823e-05 |   0.0 |  0.00
Modify  | 0.12071    | 0.12071    | 0.12071    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318584
Ave neighs/atom = 79.646
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.839458879504, Press = 0.302957016903485
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    121000  -11075.367     -11075.367     -11237.702     -11237.702      314.04831      314.04831      68795.381      68795.381      1349.15        1349.15      
    122000  -11078.248     -11078.248     -11239.792     -11239.792      312.51772      312.51772      68933.953      68933.953     -1019.3178     -1019.3178    
Loop time of 47.5976 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.222 hours/ns, 21.009 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    | 47.445     | 47.445     | 47.445     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021738   | 0.021738   | 0.021738   |   0.0 |  0.05
Output  | 3.693e-05  | 3.693e-05  | 3.693e-05  |   0.0 |  0.00
Modify  | 0.12078    | 0.12078    | 0.12078    |   0.0 |  0.25
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 319070
Ave neighs/atom = 79.7675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.83070348886, Press = -0.0184478557551501
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    122000  -11078.248     -11078.248     -11239.792     -11239.792      312.51772      312.51772      68933.953      68933.953     -1019.3178     -1019.3178    
    123000  -11076.997     -11076.997     -11240.339     -11240.339      315.9955       315.9955       68848.62       68848.62       284.5415       284.5415     
Loop time of 47.5745 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.215 hours/ns, 21.020 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    | 47.422     | 47.422     | 47.422     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021641   | 0.021641   | 0.021641   |   0.0 |  0.05
Output  | 3.6478e-05 | 3.6478e-05 | 3.6478e-05 |   0.0 |  0.00
Modify  | 0.12083    | 0.12083    | 0.12083    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318628
Ave neighs/atom = 79.657
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.821395518681, Press = -0.25395362156411
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    123000  -11076.997     -11076.997     -11240.339     -11240.339      315.9955       315.9955       68848.62       68848.62       284.5415       284.5415     
    124000  -11080.409     -11080.409     -11241.604     -11241.604      311.84325      311.84325      68900.531      68900.531     -622.96372     -622.96372    
Loop time of 47.5203 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.818 ns/day, 13.200 hours/ns, 21.044 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    | 47.368     | 47.368     | 47.368     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021674   | 0.021674   | 0.021674   |   0.0 |  0.05
Output  | 2.9776e-05 | 2.9776e-05 | 2.9776e-05 |   0.0 |  0.00
Modify  | 0.12071    | 0.12071    | 0.12071    |   0.0 |  0.25
Other   |            | 0.01017    |            |       |  0.02

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

Total # of neighbors = 318734
Ave neighs/atom = 79.6835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.815170861292, Press = 0.235991751955602
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    124000  -11080.409     -11080.409     -11241.604     -11241.604      311.84325      311.84325      68900.531      68900.531     -622.96372     -622.96372    
    125000  -11075.469     -11075.469     -11238.937     -11238.937      316.24005      316.24005      68866.577      68866.577      147.71045      147.71045    
Loop time of 47.447 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.821 ns/day, 13.180 hours/ns, 21.076 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    | 47.295     | 47.295     | 47.295     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021364   | 0.021364   | 0.021364   |   0.0 |  0.05
Output  | 4.1097e-05 | 4.1097e-05 | 4.1097e-05 |   0.0 |  0.00
Modify  | 0.12073    | 0.12073    | 0.12073    |   0.0 |  0.25
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 318566
Ave neighs/atom = 79.6415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.803955247009, Press = -0.285643785266218
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    125000  -11075.469     -11075.469     -11238.937     -11238.937      316.24005      316.24005      68866.577      68866.577      147.71045      147.71045    
    126000  -11083.738     -11083.738     -11242.316     -11242.316      306.77933      306.77933      68844.134      68844.134      98.418249      98.418249    
Loop time of 47.537 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.818 ns/day, 13.205 hours/ns, 21.036 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    | 47.385     | 47.385     | 47.385     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021277   | 0.021277   | 0.021277   |   0.0 |  0.04
Output  | 3.8452e-05 | 3.8452e-05 | 3.8452e-05 |   0.0 |  0.00
Modify  | 0.12065    | 0.12065    | 0.12065    |   0.0 |  0.25
Other   |            | 0.01017    |            |       |  0.02

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

Total # of neighbors = 318884
Ave neighs/atom = 79.721
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.796563686308, Press = 0.41254412554395
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    126000  -11083.738     -11083.738     -11242.316     -11242.316      306.77933      306.77933      68844.134      68844.134      98.418249      98.418249    
    127000  -11072.556     -11072.556     -11236.101     -11236.101      316.38741      316.38741      68897.651      68897.651     -12.332113     -12.332113    
Loop time of 47.542 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.206 hours/ns, 21.034 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    | 47.39      | 47.39      | 47.39      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021253   | 0.021253   | 0.021253   |   0.0 |  0.04
Output  | 3.6449e-05 | 3.6449e-05 | 3.6449e-05 |   0.0 |  0.00
Modify  | 0.12071    | 0.12071    | 0.12071    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318710
Ave neighs/atom = 79.6775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.789711974572, Press = -0.0884187735009826
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    127000  -11072.556     -11072.556     -11236.101     -11236.101      316.38741      316.38741      68897.651      68897.651     -12.332113     -12.332113    
    128000  -11081.781     -11081.781     -11241.573     -11241.573      309.12823      309.12823      68800.539      68800.539      926.01697      926.01697    
Loop time of 47.498 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.819 ns/day, 13.194 hours/ns, 21.054 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    | 47.346     | 47.346     | 47.346     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021248   | 0.021248   | 0.021248   |   0.0 |  0.04
Output  | 7.1164e-05 | 7.1164e-05 | 7.1164e-05 |   0.0 |  0.00
Modify  | 0.12073    | 0.12073    | 0.12073    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318860
Ave neighs/atom = 79.715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.801576361224, Press = 0.0728212403923254
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    128000  -11081.781     -11081.781     -11241.573     -11241.573      309.12823      309.12823      68800.539      68800.539      926.01697      926.01697    
    129000  -11075.252     -11075.252     -11235.52      -11235.52       310.04893      310.04893      68940.009      68940.009     -598.00402     -598.00402    
Loop time of 47.5182 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.818 ns/day, 13.199 hours/ns, 21.045 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    | 47.366     | 47.366     | 47.366     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021254   | 0.021254   | 0.021254   |   0.0 |  0.04
Output  | 2.8834e-05 | 2.8834e-05 | 2.8834e-05 |   0.0 |  0.00
Modify  | 0.12068    | 0.12068    | 0.12068    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318890
Ave neighs/atom = 79.7225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.802433345373, Press = 0.288553529920488
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    129000  -11075.252     -11075.252     -11235.52      -11235.52       310.04893      310.04893      68940.009      68940.009     -598.00402     -598.00402    
    130000  -11078.261     -11078.261     -11239.681     -11239.681      312.27852      312.27852      68825.073      68825.073      683.92011      683.92011    
Loop time of 47.5059 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.819 ns/day, 13.196 hours/ns, 21.050 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    | 47.354     | 47.354     | 47.354     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021473   | 0.021473   | 0.021473   |   0.0 |  0.05
Output  | 3.8332e-05 | 3.8332e-05 | 3.8332e-05 |   0.0 |  0.00
Modify  | 0.12066    | 0.12066    | 0.12066    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318738
Ave neighs/atom = 79.6845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.824546226186, Press = -0.417740834103458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    130000  -11078.261     -11078.261     -11239.681     -11239.681      312.27852      312.27852      68825.073      68825.073      683.92011      683.92011    
    131000  -11077.626     -11077.626     -11238.105     -11238.105      310.4577       310.4577       68893.405      68893.405     -269.49971     -269.49971    
Loop time of 47.5742 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.215 hours/ns, 21.020 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    | 47.422     | 47.422     | 47.422     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0212     | 0.0212     | 0.0212     |   0.0 |  0.04
Output  | 3.703e-05  | 3.703e-05  | 3.703e-05  |   0.0 |  0.00
Modify  | 0.12071    | 0.12071    | 0.12071    |   0.0 |  0.25
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 318872
Ave neighs/atom = 79.718
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.826150466882, Press = 0.145355600707661
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    131000  -11077.626     -11077.626     -11238.105     -11238.105      310.4577       310.4577       68893.405      68893.405     -269.49971     -269.49971    
    132000  -11079.269     -11079.269     -11239.906     -11239.906      310.76264      310.76264      68875.542      68875.542     -86.559871     -86.559871    
Loop time of 47.4455 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.821 ns/day, 13.179 hours/ns, 21.077 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    | 47.293     | 47.293     | 47.293     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021214   | 0.021214   | 0.021214   |   0.0 |  0.04
Output  | 3.5737e-05 | 3.5737e-05 | 3.5737e-05 |   0.0 |  0.00
Modify  | 0.12058    | 0.12058    | 0.12058    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318768
Ave neighs/atom = 79.692
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.828812963721, Press = -0.234256027269775
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    132000  -11079.269     -11079.269     -11239.906     -11239.906      310.76264      310.76264      68875.542      68875.542     -86.559871     -86.559871    
    133000  -11076.994     -11076.994     -11240.303     -11240.303      315.93259      315.93259      68875.425      68875.425     -216.2539      -216.2539     
Loop time of 47.5052 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.819 ns/day, 13.196 hours/ns, 21.050 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    | 47.353     | 47.353     | 47.353     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021257   | 0.021257   | 0.021257   |   0.0 |  0.04
Output  | 3.4825e-05 | 3.4825e-05 | 3.4825e-05 |   0.0 |  0.00
Modify  | 0.12069    | 0.12069    | 0.12069    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318718
Ave neighs/atom = 79.6795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.828882514797, Press = 0.303325683827382
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    133000  -11076.994     -11076.994     -11240.303     -11240.303      315.93259      315.93259      68875.425      68875.425     -216.2539      -216.2539     
    134000  -11080.403     -11080.403     -11242.345     -11242.345      313.2884       313.2884       68798.433      68798.433      862.53872      862.53872    
Loop time of 47.5987 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.222 hours/ns, 21.009 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    | 47.447     | 47.447     | 47.447     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021248   | 0.021248   | 0.021248   |   0.0 |  0.04
Output  | 2.9235e-05 | 2.9235e-05 | 2.9235e-05 |   0.0 |  0.00
Modify  | 0.1207     | 0.1207     | 0.1207     |   0.0 |  0.25
Other   |            | 0.01022    |            |       |  0.02

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

Total # of neighbors = 318584
Ave neighs/atom = 79.646
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.825465476745, Press = -0.241357626017924
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    134000  -11080.403     -11080.403     -11242.345     -11242.345      313.2884       313.2884       68798.433      68798.433      862.53872      862.53872    
    135000  -11078.631     -11078.631     -11238.474     -11238.474      309.22829      309.22829      68884.507      68884.507     -131.27804     -131.27804    
Loop time of 47.5467 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.207 hours/ns, 21.032 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    | 47.395     | 47.395     | 47.395     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021221   | 0.021221   | 0.021221   |   0.0 |  0.04
Output  | 3.5497e-05 | 3.5497e-05 | 3.5497e-05 |   0.0 |  0.00
Modify  | 0.12066    | 0.12066    | 0.12066    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318854
Ave neighs/atom = 79.7135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.836792007383, Press = 0.085466870236869
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    135000  -11078.631     -11078.631     -11238.474     -11238.474      309.22829      309.22829      68884.507      68884.507     -131.27804     -131.27804    
    136000  -11074.389     -11074.389     -11236.177     -11236.177      312.98914      312.98914      68900.546      68900.546     -169.34546     -169.34546    
Loop time of 47.5187 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.818 ns/day, 13.200 hours/ns, 21.044 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    | 47.366     | 47.366     | 47.366     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021231   | 0.021231   | 0.021231   |   0.0 |  0.04
Output  | 3.6438e-05 | 3.6438e-05 | 3.6438e-05 |   0.0 |  0.00
Modify  | 0.12084    | 0.12084    | 0.12084    |   0.0 |  0.25
Other   |            | 0.01022    |            |       |  0.02

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

Total # of neighbors = 318838
Ave neighs/atom = 79.7095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.83283086239, Press = 0.270170782367775
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    136000  -11074.389     -11074.389     -11236.177     -11236.177      312.98914      312.98914      68900.546      68900.546     -169.34546     -169.34546    
    137000  -11077.367     -11077.367     -11238.244     -11238.244      311.22851      311.22851      68794.405      68794.405      1326.9267      1326.9267    
Loop time of 47.582 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.217 hours/ns, 21.016 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    | 47.43      | 47.43      | 47.43      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021384   | 0.021384   | 0.021384   |   0.0 |  0.04
Output  | 3.6559e-05 | 3.6559e-05 | 3.6559e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.25
Other   |            | 0.01022    |            |       |  0.02

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

Total # of neighbors = 318842
Ave neighs/atom = 79.7105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.836751020273, Press = -0.212626251749929
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    137000  -11077.367     -11077.367     -11238.244     -11238.244      311.22851      311.22851      68794.405      68794.405      1326.9267      1326.9267    
    138000  -11078.58      -11078.58      -11241.193     -11241.193      314.58583      314.58583      68979.014      68979.014     -1745.8039     -1745.8039    
Loop time of 47.6123 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.226 hours/ns, 21.003 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    | 47.46      | 47.46      | 47.46      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021223   | 0.021223   | 0.021223   |   0.0 |  0.04
Output  | 2.8824e-05 | 2.8824e-05 | 2.8824e-05 |   0.0 |  0.00
Modify  | 0.12068    | 0.12068    | 0.12068    |   0.0 |  0.25
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 319028
Ave neighs/atom = 79.757
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.850170664439, Press = 0.0680556871051156
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    138000  -11078.58      -11078.58      -11241.193     -11241.193      314.58583      314.58583      68979.014      68979.014     -1745.8039     -1745.8039    
    139000  -11079.859     -11079.859     -11240.36      -11240.36       310.50077      310.50077      68799.686      68799.686      1001.104       1001.104     
Loop time of 47.5009 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.819 ns/day, 13.195 hours/ns, 21.052 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    | 47.349     | 47.349     | 47.349     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021318   | 0.021318   | 0.021318   |   0.0 |  0.04
Output  | 3.8433e-05 | 3.8433e-05 | 3.8433e-05 |   0.0 |  0.00
Modify  | 0.1207     | 0.1207     | 0.1207     |   0.0 |  0.25
Other   |            | 0.0103     |            |       |  0.02

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

Total # of neighbors = 318294
Ave neighs/atom = 79.5735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.853490002727, Press = -0.0239435573656549
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    139000  -11079.859     -11079.859     -11240.36      -11240.36       310.50077      310.50077      68799.686      68799.686      1001.104       1001.104     
    140000  -11078.508     -11078.508     -11240.786     -11240.786      313.93776      313.93776      68835.986      68835.986      455.92595      455.92595    
Loop time of 47.6006 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.222 hours/ns, 21.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    | 47.448     | 47.448     | 47.448     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021183   | 0.021183   | 0.021183   |   0.0 |  0.04
Output  | 3.9996e-05 | 3.9996e-05 | 3.9996e-05 |   0.0 |  0.00
Modify  | 0.1207     | 0.1207     | 0.1207     |   0.0 |  0.25
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 319044
Ave neighs/atom = 79.761
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.860816399803, Press = 0.135703096127802
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    140000  -11078.508     -11078.508     -11240.786     -11240.786      313.93776      313.93776      68835.986      68835.986      455.92595      455.92595    
    141000  -11078.414     -11078.414     -11239.58      -11239.58       311.78693      311.78693      68905.415      68905.415     -612.09776     -612.09776    
Loop time of 47.6357 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.232 hours/ns, 20.993 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    | 47.483     | 47.483     | 47.483     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021304   | 0.021304   | 0.021304   |   0.0 |  0.04
Output  | 3.9765e-05 | 3.9765e-05 | 3.9765e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.25
Other   |            | 0.01022    |            |       |  0.02

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

Total # of neighbors = 318870
Ave neighs/atom = 79.7175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.852321895143, Press = 0.00907044589485628
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    141000  -11078.414     -11078.414     -11239.58      -11239.58       311.78693      311.78693      68905.415      68905.415     -612.09776     -612.09776    
    142000  -11079.427     -11079.427     -11239.12      -11239.12       308.93741      308.93741      68853.31       68853.31       355.52331      355.52331    
Loop time of 47.5538 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.209 hours/ns, 21.029 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    | 47.401     | 47.401     | 47.401     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021314   | 0.021314   | 0.021314   |   0.0 |  0.04
Output  | 3.6248e-05 | 3.6248e-05 | 3.6248e-05 |   0.0 |  0.00
Modify  | 0.1207     | 0.1207     | 0.1207     |   0.0 |  0.25
Other   |            | 0.01028    |            |       |  0.02

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

Total # of neighbors = 318664
Ave neighs/atom = 79.666
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.850866191948, Press = 0.106620981037326
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    142000  -11079.427     -11079.427     -11239.12      -11239.12       308.93741      308.93741      68853.31       68853.31       355.52331      355.52331    
    143000  -11074.56      -11074.56      -11237.017     -11237.017      314.2828       314.2828       68973.306      68973.306     -1278.3766     -1278.3766    
Loop time of 47.5842 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.218 hours/ns, 21.015 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    | 47.432     | 47.432     | 47.432     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021271   | 0.021271   | 0.021271   |   0.0 |  0.04
Output  | 2.9967e-05 | 2.9967e-05 | 2.9967e-05 |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318766
Ave neighs/atom = 79.6915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.841724451665, Press = 0.0395009437892534
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    143000  -11074.56      -11074.56      -11237.017     -11237.017      314.2828       314.2828       68973.306      68973.306     -1278.3766     -1278.3766    
    144000  -11079.394     -11079.394     -11241.603     -11241.603      313.8032       313.8032       68784.066      68784.066      1123.2098      1123.2098    
Loop time of 47.494 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.819 ns/day, 13.193 hours/ns, 21.055 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    | 47.342     | 47.342     | 47.342     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021368   | 0.021368   | 0.021368   |   0.0 |  0.04
Output  | 3.8252e-05 | 3.8252e-05 | 3.8252e-05 |   0.0 |  0.00
Modify  | 0.12083    | 0.12083    | 0.12083    |   0.0 |  0.25
Other   |            | 0.01022    |            |       |  0.02

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

Total # of neighbors = 318540
Ave neighs/atom = 79.635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.852142553376, Press = -0.0341511451712576
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    144000  -11079.394     -11079.394     -11241.603     -11241.603      313.8032       313.8032       68784.066      68784.066      1123.2098      1123.2098    
    145000  -11075.781     -11075.781     -11236.38      -11236.38       310.69008      310.69008      68970.703      68970.703     -1213.2153     -1213.2153    
Loop time of 47.479 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.820 ns/day, 13.189 hours/ns, 21.062 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    | 47.327     | 47.327     | 47.327     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021251   | 0.021251   | 0.021251   |   0.0 |  0.04
Output  | 3.6909e-05 | 3.6909e-05 | 3.6909e-05 |   0.0 |  0.00
Modify  | 0.12071    | 0.12071    | 0.12071    |   0.0 |  0.25
Other   |            | 0.01031    |            |       |  0.02

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

Total # of neighbors = 319024
Ave neighs/atom = 79.756
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.850312780878, Press = -0.113860088596955
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    145000  -11075.781     -11075.781     -11236.38      -11236.38       310.69008      310.69008      68970.703      68970.703     -1213.2153     -1213.2153    
    146000  -11081.321     -11081.321     -11241.714     -11241.714      310.29145      310.29145      68824.841      68824.841      444.14456      444.14456    
Loop time of 47.5694 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.214 hours/ns, 21.022 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    | 47.417     | 47.417     | 47.417     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021207   | 0.021207   | 0.021207   |   0.0 |  0.04
Output  | 3.6028e-05 | 3.6028e-05 | 3.6028e-05 |   0.0 |  0.00
Modify  | 0.12069    | 0.12069    | 0.12069    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318562
Ave neighs/atom = 79.6405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.838755937069, Press = 0.171353155196391
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    146000  -11081.321     -11081.321     -11241.714     -11241.714      310.29145      310.29145      68824.841      68824.841      444.14456      444.14456    
    147000  -11075.5       -11075.5       -11237.932     -11237.932      314.23652      314.23652      68876.411      68876.411      99.054636      99.054636    
Loop time of 47.5613 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.211 hours/ns, 21.025 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    | 47.409     | 47.409     | 47.409     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021274   | 0.021274   | 0.021274   |   0.0 |  0.04
Output  | 3.5927e-05 | 3.5927e-05 | 3.5927e-05 |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318938
Ave neighs/atom = 79.7345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.845464775451, Press = -0.0491605303860275
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    147000  -11075.5       -11075.5       -11237.932     -11237.932      314.23652      314.23652      68876.411      68876.411      99.054636      99.054636    
    148000  -11073.442     -11073.442     -11234.985     -11234.985      312.51601      312.51601      68861.942      68861.942      575.84371      575.84371    
Loop time of 47.5179 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.818 ns/day, 13.199 hours/ns, 21.045 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    | 47.365     | 47.365     | 47.365     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021332   | 0.021332   | 0.021332   |   0.0 |  0.04
Output  | 3.0247e-05 | 3.0247e-05 | 3.0247e-05 |   0.0 |  0.00
Modify  | 0.12079    | 0.12079    | 0.12079    |   0.0 |  0.25
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 318804
Ave neighs/atom = 79.701
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.84543738387, Press = 0.119093554398305
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    148000  -11073.442     -11073.442     -11234.985     -11234.985      312.51601      312.51601      68861.942      68861.942      575.84371      575.84371    
    149000  -11080.958     -11080.958     -11237.438     -11237.438      302.72158      302.72158      68888.325      68888.325     -88.31288      -88.31288     
Loop time of 47.6035 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.223 hours/ns, 21.007 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    | 47.451     | 47.451     | 47.451     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021393   | 0.021393   | 0.021393   |   0.0 |  0.04
Output  | 4.0827e-05 | 4.0827e-05 | 4.0827e-05 |   0.0 |  0.00
Modify  | 0.12074    | 0.12074    | 0.12074    |   0.0 |  0.25
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 319016
Ave neighs/atom = 79.754
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.858591650863, Press = 0.0363278559667352
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    149000  -11080.958     -11080.958     -11237.438     -11237.438      302.72158      302.72158      68888.325      68888.325     -88.31288      -88.31288     
    150000  -11074.86      -11074.86      -11236.62      -11236.62       312.93646      312.93646      68851.237      68851.237      613.08442      613.08442    
Loop time of 47.4983 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.819 ns/day, 13.194 hours/ns, 21.053 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    | 47.346     | 47.346     | 47.346     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021411   | 0.021411   | 0.021411   |   0.0 |  0.05
Output  | 3.5978e-05 | 3.5978e-05 | 3.5978e-05 |   0.0 |  0.00
Modify  | 0.1209     | 0.1209     | 0.1209     |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318684
Ave neighs/atom = 79.671
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.870010029874, Press = 0.0847036220345243
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    150000  -11074.86      -11074.86      -11236.62      -11236.62       312.93646      312.93646      68851.237      68851.237      613.08442      613.08442    
    151000  -11079.808     -11079.808     -11239.56      -11239.56       309.05121      309.05121      68874.152      68874.152     -97.84262      -97.84262     
Loop time of 47.65 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.236 hours/ns, 20.986 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    | 47.498     | 47.498     | 47.498     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021254   | 0.021254   | 0.021254   |   0.0 |  0.04
Output  | 3.703e-05  | 3.703e-05  | 3.703e-05  |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.25
Other   |            | 0.0103     |            |       |  0.02

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

Total # of neighbors = 318858
Ave neighs/atom = 79.7145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.877445423901, Press = -0.0144061470124952
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    151000  -11079.808     -11079.808     -11239.56      -11239.56       309.05121      309.05121      68874.152      68874.152     -97.84262      -97.84262     
    152000  -11075.675     -11075.675     -11238.603     -11238.603      315.19491      315.19491      68889.149      68889.149     -117.43248     -117.43248    
Loop time of 47.6804 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.245 hours/ns, 20.973 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    | 47.528     | 47.528     | 47.528     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021338   | 0.021338   | 0.021338   |   0.0 |  0.04
Output  | 3.5166e-05 | 3.5166e-05 | 3.5166e-05 |   0.0 |  0.00
Modify  | 0.12075    | 0.12075    | 0.12075    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318764
Ave neighs/atom = 79.691
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.886727869877, Press = -0.0973547754937876
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    152000  -11075.675     -11075.675     -11238.603     -11238.603      315.19491      315.19491      68889.149      68889.149     -117.43248     -117.43248    
    153000  -11081.132     -11081.132     -11241.34      -11241.34       309.93425      309.93425      68928.218      68928.218     -1107.2681     -1107.2681    
Loop time of 47.6187 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.227 hours/ns, 21.000 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    | 47.466     | 47.466     | 47.466     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021324   | 0.021324   | 0.021324   |   0.0 |  0.04
Output  | 2.9455e-05 | 2.9455e-05 | 2.9455e-05 |   0.0 |  0.00
Modify  | 0.12069    | 0.12069    | 0.12069    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318700
Ave neighs/atom = 79.675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.880084681639, Press = 0.265719498767738
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    153000  -11081.132     -11081.132     -11241.34      -11241.34       309.93425      309.93425      68928.218      68928.218     -1107.2681     -1107.2681    
    154000  -11079.305     -11079.305     -11240.675     -11240.675      312.17995      312.17995      68755.944      68755.944      1611.3354      1611.3354    
Loop time of 47.6634 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.240 hours/ns, 20.980 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    | 47.511     | 47.511     | 47.511     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021287   | 0.021287   | 0.021287   |   0.0 |  0.04
Output  | 3.7501e-05 | 3.7501e-05 | 3.7501e-05 |   0.0 |  0.00
Modify  | 0.12076    | 0.12076    | 0.12076    |   0.0 |  0.25
Other   |            | 0.01031    |            |       |  0.02

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

Total # of neighbors = 318404
Ave neighs/atom = 79.601
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.884667541845, Press = -0.147097316902178
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    154000  -11079.305     -11079.305     -11240.675     -11240.675      312.17995      312.17995      68755.944      68755.944      1611.3354      1611.3354    
    155000  -11074.636     -11074.636     -11237.751     -11237.751      315.55591      315.55591      68915.527      68915.527     -471.51404     -471.51404    
Loop time of 47.5897 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.219 hours/ns, 21.013 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    | 47.438     | 47.438     | 47.438     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021265   | 0.021265   | 0.021265   |   0.0 |  0.04
Output  | 3.691e-05  | 3.691e-05  | 3.691e-05  |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 319114
Ave neighs/atom = 79.7785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.897639015731, Press = 0.188453067646766
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    155000  -11074.636     -11074.636     -11237.751     -11237.751      315.55591      315.55591      68915.527      68915.527     -471.51404     -471.51404    
    156000  -11078.137     -11078.137     -11237.868     -11237.868      309.01041      309.01041      68847.633      68847.633      440.58943      440.58943    
Loop time of 47.5948 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.221 hours/ns, 21.011 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    | 47.442     | 47.442     | 47.442     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02138    | 0.02138    | 0.02138    |   0.0 |  0.04
Output  | 3.6589e-05 | 3.6589e-05 | 3.6589e-05 |   0.0 |  0.00
Modify  | 0.12078    | 0.12078    | 0.12078    |   0.0 |  0.25
Other   |            | 0.01022    |            |       |  0.02

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

Total # of neighbors = 318738
Ave neighs/atom = 79.6845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.906465819989, Press = -0.0532457924714877
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    156000  -11078.137     -11078.137     -11237.868     -11237.868      309.01041      309.01041      68847.633      68847.633      440.58943      440.58943    
    157000  -11078.584     -11078.584     -11239.929     -11239.929      312.13283      312.13283      68867.367      68867.367      86.289544      86.289544    
Loop time of 47.651 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.236 hours/ns, 20.986 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    | 47.499     | 47.499     | 47.499     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021256   | 0.021256   | 0.021256   |   0.0 |  0.04
Output  | 3.7831e-05 | 3.7831e-05 | 3.7831e-05 |   0.0 |  0.00
Modify  | 0.12074    | 0.12074    | 0.12074    |   0.0 |  0.25
Other   |            | 0.01031    |            |       |  0.02

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

Total # of neighbors = 318912
Ave neighs/atom = 79.728
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.906168601714, Press = -0.0516249374533129
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    157000  -11078.584     -11078.584     -11239.929     -11239.929      312.13283      312.13283      68867.367      68867.367      86.289544      86.289544    
    158000  -11073.398     -11073.398     -11237.13      -11237.13       316.75108      316.75108      68906.38       68906.38      -290.5256      -290.5256     
Loop time of 47.6475 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.235 hours/ns, 20.987 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    | 47.495     | 47.495     | 47.495     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021251   | 0.021251   | 0.021251   |   0.0 |  0.04
Output  | 2.8964e-05 | 2.8964e-05 | 2.8964e-05 |   0.0 |  0.00
Modify  | 0.12073    | 0.12073    | 0.12073    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318718
Ave neighs/atom = 79.6795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.920500097375, Press = 0.162079956019596
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    158000  -11073.398     -11073.398     -11237.13      -11237.13       316.75108      316.75108      68906.38       68906.38      -290.5256      -290.5256     
    159000  -11081.733     -11081.733     -11243.306     -11243.306      312.57437      312.57437      68789.222      68789.222      828.11769      828.11769    
Loop time of 47.579 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.216 hours/ns, 21.018 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    | 47.427     | 47.427     | 47.427     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021333   | 0.021333   | 0.021333   |   0.0 |  0.04
Output  | 3.9454e-05 | 3.9454e-05 | 3.9454e-05 |   0.0 |  0.00
Modify  | 0.12063    | 0.12063    | 0.12063    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318770
Ave neighs/atom = 79.6925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.922007084164, Press = -0.181378038215626
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    159000  -11081.733     -11081.733     -11243.306     -11243.306      312.57437      312.57437      68789.222      68789.222      828.11769      828.11769    
    160000  -11078.619     -11078.619     -11240.233     -11240.233      312.65416      312.65416      68951.135      68951.135     -1361.9587     -1361.9587    
Loop time of 47.6475 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.235 hours/ns, 20.987 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    | 47.495     | 47.495     | 47.495     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021287   | 0.021287   | 0.021287   |   0.0 |  0.04
Output  | 3.7771e-05 | 3.7771e-05 | 3.7771e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.25
Other   |            | 0.01031    |            |       |  0.02

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

Total # of neighbors = 318762
Ave neighs/atom = 79.6905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.92464375158, Press = 0.161853622765368
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    160000  -11078.619     -11078.619     -11240.233     -11240.233      312.65416      312.65416      68951.135      68951.135     -1361.9587     -1361.9587    
    161000  -11076.818     -11076.818     -11236.006     -11236.006      307.96115      307.96115      68868.589      68868.589      361.96758      361.96758    
Loop time of 47.5778 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.216 hours/ns, 21.018 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    | 47.426     | 47.426     | 47.426     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021173   | 0.021173   | 0.021173   |   0.0 |  0.04
Output  | 3.6259e-05 | 3.6259e-05 | 3.6259e-05 |   0.0 |  0.00
Modify  | 0.12069    | 0.12069    | 0.12069    |   0.0 |  0.25
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 318472
Ave neighs/atom = 79.618
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.92893446702, Press = 0.0464777558707751
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    161000  -11076.818     -11076.818     -11236.006     -11236.006      307.96115      307.96115      68868.589      68868.589      361.96758      361.96758    
    162000  -11079.001     -11079.001     -11239.865     -11239.865      311.2019       311.2019       68848.602      68848.602      314.22096      314.22096    
Loop time of 47.632 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.231 hours/ns, 20.994 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    | 47.48      | 47.48      | 47.48      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021303   | 0.021303   | 0.021303   |   0.0 |  0.04
Output  | 2.9235e-05 | 2.9235e-05 | 2.9235e-05 |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.25
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 318758
Ave neighs/atom = 79.6895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.933052258361, Press = 0.0606469604976172
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    162000  -11079.001     -11079.001     -11239.865     -11239.865      311.2019       311.2019       68848.602      68848.602      314.22096      314.22096    
    163000  -11075.868     -11075.868     -11238.598     -11238.598      314.81135      314.81135      68822.218      68822.218      899.36341      899.36341    
Loop time of 47.6252 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.229 hours/ns, 20.997 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    | 47.473     | 47.473     | 47.473     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02129    | 0.02129    | 0.02129    |   0.0 |  0.04
Output  | 3.8683e-05 | 3.8683e-05 | 3.8683e-05 |   0.0 |  0.00
Modify  | 0.12071    | 0.12071    | 0.12071    |   0.0 |  0.25
Other   |            | 0.01037    |            |       |  0.02

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

Total # of neighbors = 318764
Ave neighs/atom = 79.691
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.9327404928, Press = 0.107689788114507
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    163000  -11075.868     -11075.868     -11238.598     -11238.598      314.81135      314.81135      68822.218      68822.218      899.36341      899.36341    
    164000  -11082.057     -11082.057     -11239.332     -11239.332      304.25972      304.25972      68996.974      68996.974     -1921.5969     -1921.5969    
Loop time of 47.6197 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.228 hours/ns, 21.000 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    | 47.467     | 47.467     | 47.467     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021337   | 0.021337   | 0.021337   |   0.0 |  0.04
Output  | 3.6469e-05 | 3.6469e-05 | 3.6469e-05 |   0.0 |  0.00
Modify  | 0.12084    | 0.12084    | 0.12084    |   0.0 |  0.25
Other   |            | 0.01022    |            |       |  0.02

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

Total # of neighbors = 318944
Ave neighs/atom = 79.736
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.920126420693, Press = -0.119699567176828
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    164000  -11082.057     -11082.057     -11239.332     -11239.332      304.25972      304.25972      68996.974      68996.974     -1921.5969     -1921.5969    
    165000  -11080.663     -11080.663     -11244.174     -11244.174      316.32297      316.32297      68793.848      68793.848      756.25958      756.25958    
Loop time of 47.5649 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.212 hours/ns, 21.024 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    | 47.413     | 47.413     | 47.413     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021258   | 0.021258   | 0.021258   |   0.0 |  0.04
Output  | 3.71e-05   | 3.71e-05   | 3.71e-05   |   0.0 |  0.00
Modify  | 0.12075    | 0.12075    | 0.12075    |   0.0 |  0.25
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 318454
Ave neighs/atom = 79.6135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.918563821765, Press = -0.152505116628068
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    165000  -11080.663     -11080.663     -11244.174     -11244.174      316.32297      316.32297      68793.848      68793.848      756.25958      756.25958    
    166000  -11079.262     -11079.262     -11240.697     -11240.697      312.30678      312.30678      68929.994      68929.994     -1058.935      -1058.935     
Loop time of 47.6863 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.246 hours/ns, 20.970 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    | 47.534     | 47.534     | 47.534     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021347   | 0.021347   | 0.021347   |   0.0 |  0.04
Output  | 3.5236e-05 | 3.5236e-05 | 3.5236e-05 |   0.0 |  0.00
Modify  | 0.12085    | 0.12085    | 0.12085    |   0.0 |  0.25
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 318816
Ave neighs/atom = 79.704
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.92354096082, Press = 0.326149216422561
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    166000  -11079.262     -11079.262     -11240.697     -11240.697      312.30678      312.30678      68929.994      68929.994     -1058.935      -1058.935     
    167000  -11073.71      -11073.71      -11238.337     -11238.337      318.48327      318.48327      68848.833      68848.833      524.22386      524.22386    
Loop time of 47.6068 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.224 hours/ns, 21.005 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    | 47.455     | 47.455     | 47.455     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021361   | 0.021361   | 0.021361   |   0.0 |  0.04
Output  | 2.8694e-05 | 2.8694e-05 | 2.8694e-05 |   0.0 |  0.00
Modify  | 0.12068    | 0.12068    | 0.12068    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318526
Ave neighs/atom = 79.6315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.923940940843, Press = -0.104008514184754
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    167000  -11073.71      -11073.71      -11238.337     -11238.337      318.48327      318.48327      68848.833      68848.833      524.22386      524.22386    
    168000  -11076.369     -11076.369     -11237.935     -11237.935      312.55908      312.55908      68852.047      68852.047      455.30725      455.30725    
Loop time of 47.5909 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.815 ns/day, 13.220 hours/ns, 21.012 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    | 47.439     | 47.439     | 47.439     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021295   | 0.021295   | 0.021295   |   0.0 |  0.04
Output  | 3.5998e-05 | 3.5998e-05 | 3.5998e-05 |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.25
Other   |            | 0.01018    |            |       |  0.02

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

Total # of neighbors = 318818
Ave neighs/atom = 79.7045
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.92626549127, Press = 0.139739579788714
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    168000  -11076.369     -11076.369     -11237.935     -11237.935      312.55908      312.55908      68852.047      68852.047      455.30725      455.30725    
    169000  -11077.786     -11077.786     -11241.883     -11241.883      317.45607      317.45607      68817.846      68817.846      622.89111      622.89111    
Loop time of 47.5892 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.219 hours/ns, 21.013 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    | 47.437     | 47.437     | 47.437     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021168   | 0.021168   | 0.021168   |   0.0 |  0.04
Output  | 3.6589e-05 | 3.6589e-05 | 3.6589e-05 |   0.0 |  0.00
Modify  | 0.12075    | 0.12075    | 0.12075    |   0.0 |  0.25
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 318830
Ave neighs/atom = 79.7075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.924295361935, Press = -0.144382364721308
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    169000  -11077.786     -11077.786     -11241.883     -11241.883      317.45607      317.45607      68817.846      68817.846      622.89111      622.89111    
    170000  -11075.941     -11075.941     -11241.466     -11241.466      320.2197       320.2197       68912.921      68912.921     -756.78521     -756.78521    
Loop time of 47.6482 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.236 hours/ns, 20.987 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    | 47.496     | 47.496     | 47.496     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0213     | 0.0213     | 0.0213     |   0.0 |  0.04
Output  | 3.711e-05  | 3.711e-05  | 3.711e-05  |   0.0 |  0.00
Modify  | 0.12071    | 0.12071    | 0.12071    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318772
Ave neighs/atom = 79.693
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.926357877387, Press = -0.00368600853153958
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    170000  -11075.941     -11075.941     -11241.466     -11241.466      320.2197       320.2197       68912.921      68912.921     -756.78521     -756.78521    
    171000  -11070.024     -11070.024     -11235.949     -11235.949      320.9922       320.9922       68912.176      68912.176     -260.52728     -260.52728    
Loop time of 47.6481 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.236 hours/ns, 20.987 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    | 47.496     | 47.496     | 47.496     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021226   | 0.021226   | 0.021226   |   0.0 |  0.04
Output  | 3.5918e-05 | 3.5918e-05 | 3.5918e-05 |   0.0 |  0.00
Modify  | 0.1207     | 0.1207     | 0.1207     |   0.0 |  0.25
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 318656
Ave neighs/atom = 79.664
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.933466620215, Press = 0.0550398387838218
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    171000  -11070.024     -11070.024     -11235.949     -11235.949      320.9922       320.9922       68912.176      68912.176     -260.52728     -260.52728    
    172000  -11077.003     -11077.003     -11239.97      -11239.97       315.27187      315.27187      68843.931      68843.931      362.06289      362.06289    
Loop time of 47.6694 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.241 hours/ns, 20.978 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    | 47.517     | 47.517     | 47.517     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021311   | 0.021311   | 0.021311   |   0.0 |  0.04
Output  | 2.9396e-05 | 2.9396e-05 | 2.9396e-05 |   0.0 |  0.00
Modify  | 0.12077    | 0.12077    | 0.12077    |   0.0 |  0.25
Other   |            | 0.01022    |            |       |  0.02

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

Total # of neighbors = 318906
Ave neighs/atom = 79.7265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.94334460713, Press = -0.0610743332832976
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    172000  -11077.003     -11077.003     -11239.97      -11239.97       315.27187      315.27187      68843.931      68843.931      362.06289      362.06289    
    173000  -11073.637     -11073.637     -11235.738     -11235.738      313.5953       313.5953       68915.185      68915.185     -337.16839     -337.16839    
Loop time of 47.6806 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.812 ns/day, 13.245 hours/ns, 20.973 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    | 47.528     | 47.528     | 47.528     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021249   | 0.021249   | 0.021249   |   0.0 |  0.04
Output  | 3.6388e-05 | 3.6388e-05 | 3.6388e-05 |   0.0 |  0.00
Modify  | 0.12075    | 0.12075    | 0.12075    |   0.0 |  0.25
Other   |            | 0.01022    |            |       |  0.02

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

Total # of neighbors = 318926
Ave neighs/atom = 79.7315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.947356841599, Press = 0.241404473440579
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    173000  -11073.637     -11073.637     -11235.738     -11235.738      313.5953       313.5953       68915.185      68915.185     -337.16839     -337.16839    
    174000  -11084.124     -11084.124     -11241.984     -11241.984      305.39191      305.39191      68852.51       68852.51      -29.634639     -29.634639    
Loop time of 47.5418 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.206 hours/ns, 21.034 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    | 47.389     | 47.389     | 47.389     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021282   | 0.021282   | 0.021282   |   0.0 |  0.04
Output  | 3.703e-05  | 3.703e-05  | 3.703e-05  |   0.0 |  0.00
Modify  | 0.12076    | 0.12076    | 0.12076    |   0.0 |  0.25
Other   |            | 0.0103     |            |       |  0.02

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

Total # of neighbors = 318744
Ave neighs/atom = 79.686
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.945907357716, Press = -0.170920251284054
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    174000  -11084.124     -11084.124     -11241.984     -11241.984      305.39191      305.39191      68852.51       68852.51      -29.634639     -29.634639    
    175000  -11077.552     -11077.552     -11241.35      -11241.35       316.87749      316.87749      68871.996      68871.996     -235.91908     -235.91908    
Loop time of 47.5632 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.212 hours/ns, 21.025 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    | 47.411     | 47.411     | 47.411     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021278   | 0.021278   | 0.021278   |   0.0 |  0.04
Output  | 3.719e-05  | 3.719e-05  | 3.719e-05  |   0.0 |  0.00
Modify  | 0.12079    | 0.12079    | 0.12079    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318860
Ave neighs/atom = 79.715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.938349635904, Press = 0.179402774657715
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    175000  -11077.552     -11077.552     -11241.35      -11241.35       316.87749      316.87749      68871.996      68871.996     -235.91908     -235.91908    
    176000  -11076.7       -11076.7       -11237.51      -11237.51       311.0984       311.0984       68862.094      68862.094      346.30082      346.30082    
Loop time of 47.6219 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.228 hours/ns, 20.999 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    | 47.47      | 47.47      | 47.47      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021291   | 0.021291   | 0.021291   |   0.0 |  0.04
Output  | 3.5227e-05 | 3.5227e-05 | 3.5227e-05 |   0.0 |  0.00
Modify  | 0.12071    | 0.12071    | 0.12071    |   0.0 |  0.25
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 318716
Ave neighs/atom = 79.679
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.941711814054, Press = -0.109227159968065
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    176000  -11076.7       -11076.7       -11237.51      -11237.51       311.0984       311.0984       68862.094      68862.094      346.30082      346.30082    
    177000  -11072.5       -11072.5       -11236.75      -11236.75       317.75234      317.75234      68860.909      68860.909      487.28386      487.28386    
Loop time of 47.6612 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.239 hours/ns, 20.981 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    | 47.509     | 47.509     | 47.509     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02138    | 0.02138    | 0.02138    |   0.0 |  0.04
Output  | 3.0067e-05 | 3.0067e-05 | 3.0067e-05 |   0.0 |  0.00
Modify  | 0.1207     | 0.1207     | 0.1207     |   0.0 |  0.25
Other   |            | 0.01032    |            |       |  0.02

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

Total # of neighbors = 318806
Ave neighs/atom = 79.7015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.943949887489, Press = 0.051678250040474
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    177000  -11072.5       -11072.5       -11236.75      -11236.75       317.75234      317.75234      68860.909      68860.909      487.28386      487.28386    
    178000  -11080.65      -11080.65      -11239.143     -11239.143      306.61425      306.61425      68853.984      68853.984      423.9017       423.9017     
Loop time of 47.6427 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.234 hours/ns, 20.990 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    | 47.49      | 47.49      | 47.49      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021244   | 0.021244   | 0.021244   |   0.0 |  0.04
Output  | 3.76e-05   | 3.76e-05   | 3.76e-05   |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.25
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 318872
Ave neighs/atom = 79.718
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.94614720223, Press = 0.0285589830992308
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    178000  -11080.65      -11080.65      -11239.143     -11239.143      306.61425      306.61425      68853.984      68853.984      423.9017       423.9017     
    179000  -11075.179     -11075.179     -11238.781     -11238.781      316.49799      316.49799      68817.231      68817.231      874.88322      874.88322    
Loop time of 47.5683 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.816 ns/day, 13.213 hours/ns, 21.022 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    | 47.416     | 47.416     | 47.416     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021339   | 0.021339   | 0.021339   |   0.0 |  0.04
Output  | 3.6329e-05 | 3.6329e-05 | 3.6329e-05 |   0.0 |  0.00
Modify  | 0.12093    | 0.12093    | 0.12093    |   0.0 |  0.25
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 318782
Ave neighs/atom = 79.6955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.936132340066, Press = -0.165938071492237
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    179000  -11075.179     -11075.179     -11238.781     -11238.781      316.49799      316.49799      68817.231      68817.231      874.88322      874.88322    
    180000  -11078.148     -11078.148     -11237.986     -11237.986      309.2186       309.2186       68899.676      68899.676     -143.33364     -143.33364    
Loop time of 47.6602 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.813 ns/day, 13.239 hours/ns, 20.982 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    | 47.508     | 47.508     | 47.508     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021314   | 0.021314   | 0.021314   |   0.0 |  0.04
Output  | 4.2861e-05 | 4.2861e-05 | 4.2861e-05 |   0.0 |  0.00
Modify  | 0.12089    | 0.12089    | 0.12089    |   0.0 |  0.25
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 318946
Ave neighs/atom = 79.7365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.938964534622, Press = 0.215557985860262
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    180000  -11078.148     -11078.148     -11237.986     -11237.986      309.2186       309.2186       68899.676      68899.676     -143.33364     -143.33364    
    181000  -11077.972     -11077.972     -11240.549     -11240.549      314.51626      314.51626      68810.695      68810.695      878.14141      878.14141    
Loop time of 47.5623 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.817 ns/day, 13.212 hours/ns, 21.025 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    | 47.41      | 47.41      | 47.41      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021341   | 0.021341   | 0.021341   |   0.0 |  0.04
Output  | 3.7471e-05 | 3.7471e-05 | 3.7471e-05 |   0.0 |  0.00
Modify  | 0.12086    | 0.12086    | 0.12086    |   0.0 |  0.25
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 318586
Ave neighs/atom = 79.6465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.94437765426, Press = -0.00283424205387007
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
    181000  -11077.972     -11077.972     -11240.549     -11240.549      314.51626      314.51626      68810.695      68810.695      878.14141      878.14141    
    182000  -11073.207     -11073.207     -11236.012     -11236.012      314.95695      314.95695      68892.446      68892.446      61.82692       61.82692     
Loop time of 47.6176 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.814 ns/day, 13.227 hours/ns, 21.001 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    | 47.465     | 47.465     | 47.465     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021272   | 0.021272   | 0.021272   |   0.0 |  0.04
Output  | 3.2331e-05 | 3.2331e-05 | 3.2331e-05 |   0.0 |  0.00
Modify  | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.25
Other   |            | 0.01024    |            |       |  0.02

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0