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

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

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

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

kim_interactions Cr

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

kim interactions Cr
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeBaskesKim_2001_Cr__MO_134550636109_001
pair_coeff * * Cr
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 51.9961

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8119.0848     -8119.0848     -8200          -8200           313.15         313.15         23912.212      23912.212      3614.3322      3614.3322    
      1000  -8031.4482     -8031.4482     -8116.2855     -8116.2855      328.32891      328.32891      24096.422      24096.422      294.28772      294.28772    
Loop time of 93.717 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.922 ns/day, 26.032 hours/ns, 10.670 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.246     | 93.246     | 93.246     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074413   | 0.074413   | 0.074413   |   0.0 |  0.08
Output  | 0.00021932 | 0.00021932 | 0.00021932 |   0.0 |  0.00
Modify  | 0.34019    | 0.34019    | 0.34019    |   0.0 |  0.36
Other   |            | 0.05619    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116000 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8031.4482     -8031.4482     -8116.2855     -8116.2855      328.32891      328.32891      24096.422      24096.422      294.28772      294.28772    
      2000  -8033.3256     -8033.3256     -8111.5068     -8111.5068      302.56914      302.56914      24120.17       24120.17      -1646.1729     -1646.1729    
Loop time of 109.285 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.357 hours/ns, 9.150 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    | 108.75     | 108.75     | 108.75     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080341   | 0.080341   | 0.080341   |   0.0 |  0.07
Output  | 0.00020686 | 0.00020686 | 0.00020686 |   0.0 |  0.00
Modify  | 0.3976     | 0.3976     | 0.3976     |   0.0 |  0.36
Other   |            | 0.06172    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2949 ave        2949 max        2949 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116192 ave      116192 max      116192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116192
Ave neighs/atom = 58.096
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8033.3256     -8033.3256     -8111.5068     -8111.5068      302.56914      302.56914      24120.17       24120.17      -1646.1729     -1646.1729    
      3000  -8033.4728     -8033.4728     -8111.9074     -8111.9074      303.55003      303.55003      24104.445      24104.445     -354.90838     -354.90838    
Loop time of 113.633 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.565 hours/ns, 8.800 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    | 113.08     | 113.08     | 113.08     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082459   | 0.082459   | 0.082459   |   0.0 |  0.07
Output  | 0.00020891 | 0.00020891 | 0.00020891 |   0.0 |  0.00
Modify  | 0.41272    | 0.41272    | 0.41272    |   0.0 |  0.36
Other   |            | 0.06201    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2947 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116274 ave      116274 max      116274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116274
Ave neighs/atom = 58.137
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8033.4728     -8033.4728     -8111.9074     -8111.9074      303.55003      303.55003      24104.445      24104.445     -354.90838     -354.90838    
      4000  -8032.231      -8032.231      -8115.0644     -8115.0644      320.57394      320.57394      24071.012      24071.012      1979.3961      1979.3961    
Loop time of 98.826 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.452 hours/ns, 10.119 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.351     | 98.351     | 98.351     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074045   | 0.074045   | 0.074045   |   0.0 |  0.07
Output  | 0.00020832 | 0.00020832 | 0.00020832 |   0.0 |  0.00
Modify  | 0.3442     | 0.3442     | 0.3442     |   0.0 |  0.35
Other   |            | 0.05638    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116240 ave      116240 max      116240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116240
Ave neighs/atom = 58.12
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8032.231      -8032.231      -8115.0644     -8115.0644      320.57394      320.57394      24071.012      24071.012      1979.3961      1979.3961    
      5000  -8033.9861     -8033.9861     -8114.1873     -8114.1873      310.38708      310.38708      24080.433      24080.433      1502.5639      1502.5639    
Loop time of 96.2816 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.745 hours/ns, 10.386 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.813     | 95.813     | 95.813     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073628   | 0.073628   | 0.073628   |   0.0 |  0.08
Output  | 0.00016491 | 0.00016491 | 0.00016491 |   0.0 |  0.00
Modify  | 0.33886    | 0.33886    | 0.33886    |   0.0 |  0.35
Other   |            | 0.05582    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116270 ave      116270 max      116270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116270
Ave neighs/atom = 58.135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 310.505877160689, Press = 2108.16093035447
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8033.9861     -8033.9861     -8114.1873     -8114.1873      310.38708      310.38708      24080.433      24080.433      1502.5639      1502.5639    
      6000  -8031.9152     -8031.9152     -8113.6606     -8113.6606      316.36348      316.36348      24138.155      24138.155     -2982.8726     -2982.8726    
Loop time of 96.2799 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.744 hours/ns, 10.386 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.794     | 95.794     | 95.794     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073442   | 0.073442   | 0.073442   |   0.0 |  0.08
Output  | 0.00016648 | 0.00016648 | 0.00016648 |   0.0 |  0.00
Modify  | 0.35746    | 0.35746    | 0.35746    |   0.0 |  0.37
Other   |            | 0.05531    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116254 ave      116254 max      116254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116254
Ave neighs/atom = 58.127
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.328116610787, Press = 91.294092173719
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8031.9152     -8031.9152     -8113.6606     -8113.6606      316.36348      316.36348      24138.155      24138.155     -2982.8726     -2982.8726    
      7000  -8036.7364     -8036.7364     -8116.0932     -8116.0932      307.11914      307.11914      24100.523      24100.523     -562.04393     -562.04393    
Loop time of 108.292 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.798 ns/day, 30.081 hours/ns, 9.234 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    | 107.73     | 107.73     | 107.73     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080301   | 0.080301   | 0.080301   |   0.0 |  0.07
Output  | 0.00016708 | 0.00016708 | 0.00016708 |   0.0 |  0.00
Modify  | 0.42002    | 0.42002    | 0.42002    |   0.0 |  0.39
Other   |            | 0.06197    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116224 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.819937073416, Press = 9.26497083001646
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8036.7364     -8036.7364     -8116.0932     -8116.0932      307.11914      307.11914      24100.523      24100.523     -562.04393     -562.04393    
      8000  -8031.483      -8031.483      -8112.8135     -8112.8135      314.75727      314.75727      24073.359      24073.359      1954.9681      1954.9681    
Loop time of 96.4725 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.798 hours/ns, 10.366 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.983     | 95.983     | 95.983     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073561   | 0.073561   | 0.073561   |   0.0 |  0.08
Output  | 0.00016999 | 0.00016999 | 0.00016999 |   0.0 |  0.00
Modify  | 0.35954    | 0.35954    | 0.35954    |   0.0 |  0.37
Other   |            | 0.0566     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2947 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116194 ave      116194 max      116194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116194
Ave neighs/atom = 58.097
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.748302930454, Press = 27.3773518046993
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8031.483      -8031.483      -8112.8135     -8112.8135      314.75727      314.75727      24073.359      24073.359      1954.9681      1954.9681    
      9000  -8035.299      -8035.299      -8116.2316     -8116.2316      313.21781      313.21781      24095.235      24095.235     -77.446305     -77.446305    
Loop time of 108.763 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.794 ns/day, 30.212 hours/ns, 9.194 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.2      | 108.2      | 108.2      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080363   | 0.080363   | 0.080363   |   0.0 |  0.07
Output  | 0.00016694 | 0.00016694 | 0.00016694 |   0.0 |  0.00
Modify  | 0.42397    | 0.42397    | 0.42397    |   0.0 |  0.39
Other   |            | 0.06163    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116226 ave      116226 max      116226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116226
Ave neighs/atom = 58.113
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.639019346246, Press = 34.4665166295099
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8035.299      -8035.299      -8116.2316     -8116.2316      313.21781      313.21781      24095.235      24095.235     -77.446305     -77.446305    
     10000  -8032.9393     -8032.9393     -8114.0123     -8114.0123      313.76081      313.76081      24141.973      24141.973     -3210.9753     -3210.9753    
Loop time of 112.661 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.295 hours/ns, 8.876 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.07     | 112.07     | 112.07     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083318   | 0.083318   | 0.083318   |   0.0 |  0.07
Output  | 0.00016952 | 0.00016952 | 0.00016952 |   0.0 |  0.00
Modify  | 0.44677    | 0.44677    | 0.44677    |   0.0 |  0.40
Other   |            | 0.06328    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116218 ave      116218 max      116218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116218
Ave neighs/atom = 58.109
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.407493520582, Press = 13.6423765111445
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8032.9393     -8032.9393     -8114.0123     -8114.0123      313.76081      313.76081      24141.973      24141.973     -3210.9753     -3210.9753    
     11000  -8030.5082     -8030.5082     -8112.6297     -8112.6297      317.81835      317.81835      24099.059      24099.059      134.34911      134.34911    
Loop time of 112.803 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.334 hours/ns, 8.865 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.21     | 112.21     | 112.21     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08297    | 0.08297    | 0.08297    |   0.0 |  0.07
Output  | 0.00016688 | 0.00016688 | 0.00016688 |   0.0 |  0.00
Modify  | 0.44374    | 0.44374    | 0.44374    |   0.0 |  0.39
Other   |            | 0.06369    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116202 ave      116202 max      116202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116202
Ave neighs/atom = 58.101
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.562995561874, Press = -3.6140110246105
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8030.5082     -8030.5082     -8112.6297     -8112.6297      317.81835      317.81835      24099.059      24099.059      134.34911      134.34911    
     12000  -8033.0006     -8033.0006     -8111.6274     -8111.6274      304.29395      304.29395      24067.304      24067.304      2547.4018      2547.4018    
Loop time of 112.823 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.340 hours/ns, 8.863 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.23     | 112.23     | 112.23     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08329    | 0.08329    | 0.08329    |   0.0 |  0.07
Output  | 0.00016916 | 0.00016916 | 0.00016916 |   0.0 |  0.00
Modify  | 0.447      | 0.447      | 0.447      |   0.0 |  0.40
Other   |            | 0.06382    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116224 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.299188210786, Press = 13.7283839730299
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8033.0006     -8033.0006     -8111.6274     -8111.6274      304.29395      304.29395      24067.304      24067.304      2547.4018      2547.4018    
     13000  -8031.861      -8031.861      -8111.3967     -8111.3967      307.81112      307.81112      24100.377      24100.377      66.696328      66.696328    
Loop time of 112.64 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.289 hours/ns, 8.878 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.04     | 112.04     | 112.04     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083898   | 0.083898   | 0.083898   |   0.0 |  0.07
Output  | 0.00021286 | 0.00021286 | 0.00021286 |   0.0 |  0.00
Modify  | 0.4497     | 0.4497     | 0.4497     |   0.0 |  0.40
Other   |            | 0.06374    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116240 ave      116240 max      116240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116240
Ave neighs/atom = 58.12
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.508922911309, Press = 16.1452578051109
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8031.861      -8031.861      -8111.3967     -8111.3967      307.81112      307.81112      24100.377      24100.377      66.696328      66.696328    
     14000  -8033.4029     -8033.4029     -8113.4616     -8113.4616      309.83533      309.83533      24117.172      24117.172     -1409.1841     -1409.1841    
Loop time of 113.23 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.453 hours/ns, 8.832 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.64     | 112.64     | 112.64     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083282   | 0.083282   | 0.083282   |   0.0 |  0.07
Output  | 0.00017047 | 0.00017047 | 0.00017047 |   0.0 |  0.00
Modify  | 0.44752    | 0.44752    | 0.44752    |   0.0 |  0.40
Other   |            | 0.06357    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116260 ave      116260 max      116260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116260
Ave neighs/atom = 58.13
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.64855365488, Press = 7.04070979601401
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8033.4029     -8033.4029     -8113.4616     -8113.4616      309.83533      309.83533      24117.172      24117.172     -1409.1841     -1409.1841    
     15000  -8031.628      -8031.628      -8112.2718     -8112.2718      312.09983      312.09983      24087.353      24087.353      1090.03        1090.03      
Loop time of 113.376 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.493 hours/ns, 8.820 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    | 112.79     | 112.79     | 112.79     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083457   | 0.083457   | 0.083457   |   0.0 |  0.07
Output  | 0.00021456 | 0.00021456 | 0.00021456 |   0.0 |  0.00
Modify  | 0.44179    | 0.44179    | 0.44179    |   0.0 |  0.39
Other   |            | 0.06318    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116210 ave      116210 max      116210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116210
Ave neighs/atom = 58.105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.597967231223, Press = 4.88950717510629
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8031.628      -8031.628      -8112.2718     -8112.2718      312.09983      312.09983      24087.353      24087.353      1090.03        1090.03      
     16000  -8035.8047     -8035.8047     -8115.8559     -8115.8559      309.8065       309.8065       24029.849      24029.849      5007.8885      5007.8885    
Loop time of 113.564 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.546 hours/ns, 8.806 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    | 112.97     | 112.97     | 112.97     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08418    | 0.08418    | 0.08418    |   0.0 |  0.07
Output  | 0.00022841 | 0.00022841 | 0.00022841 |   0.0 |  0.00
Modify  | 0.44832    | 0.44832    | 0.44832    |   0.0 |  0.39
Other   |            | 0.06319    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116230 ave      116230 max      116230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116230
Ave neighs/atom = 58.115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.542901482534, Press = 15.7621376989302
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8035.8047     -8035.8047     -8115.8559     -8115.8559      309.8065       309.8065       24029.849      24029.849      5007.8885      5007.8885    
     17000  -8033.6596     -8033.6596     -8115.0596     -8115.0596      315.02631      315.02631      24124.069      24124.069     -2042.6611     -2042.6611    
Loop time of 113.26 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.461 hours/ns, 8.829 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    | 112.67     | 112.67     | 112.67     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083674   | 0.083674   | 0.083674   |   0.0 |  0.07
Output  | 0.00022909 | 0.00022909 | 0.00022909 |   0.0 |  0.00
Modify  | 0.4454     | 0.4454     | 0.4454     |   0.0 |  0.39
Other   |            | 0.06311    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116262 ave      116262 max      116262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116262
Ave neighs/atom = 58.131
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.335360460688, Press = 13.0104092237923
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8033.6596     -8033.6596     -8115.0596     -8115.0596      315.02631      315.02631      24124.069      24124.069     -2042.6611     -2042.6611    
     18000  -8032.5671     -8032.5671     -8112.8727     -8112.8727      310.79107      310.79107      24122.765      24122.765     -1732.0793     -1732.0793    
Loop time of 112.615 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.282 hours/ns, 8.880 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.02     | 112.02     | 112.02     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084365   | 0.084365   | 0.084365   |   0.0 |  0.07
Output  | 0.00016673 | 0.00016673 | 0.00016673 |   0.0 |  0.00
Modify  | 0.44503    | 0.44503    | 0.44503    |   0.0 |  0.40
Other   |            | 0.06298    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116180 ave      116180 max      116180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116180
Ave neighs/atom = 58.09
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.45628099361, Press = 3.43635468528892
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8032.5671     -8032.5671     -8112.8727     -8112.8727      310.79107      310.79107      24122.765      24122.765     -1732.0793     -1732.0793    
     19000  -8036.7768     -8036.7768     -8116.2029     -8116.2029      307.38708      307.38708      24076.063      24076.063      1425.5029      1425.5029    
Loop time of 112.646 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.290 hours/ns, 8.877 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.05     | 112.05     | 112.05     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084359   | 0.084359   | 0.084359   |   0.0 |  0.07
Output  | 0.00021497 | 0.00021497 | 0.00021497 |   0.0 |  0.00
Modify  | 0.44654    | 0.44654    | 0.44654    |   0.0 |  0.40
Other   |            | 0.06243    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116214 ave      116214 max      116214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116214
Ave neighs/atom = 58.107
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.279452582281, Press = 3.97995610704409
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8036.7768     -8036.7768     -8116.2029     -8116.2029      307.38708      307.38708      24076.063      24076.063      1425.5029      1425.5029    
     20000  -8033.3491     -8033.3491     -8114.07       -8114.07        312.3982       312.3982       24080.626      24080.626      1462.2598      1462.2598    
Loop time of 112.95 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.375 hours/ns, 8.853 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.36     | 112.36     | 112.36     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08433    | 0.08433    | 0.08433    |   0.0 |  0.07
Output  | 0.00016748 | 0.00016748 | 0.00016748 |   0.0 |  0.00
Modify  | 0.44632    | 0.44632    | 0.44632    |   0.0 |  0.40
Other   |            | 0.06255    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116232 ave      116232 max      116232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116232
Ave neighs/atom = 58.116
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.329485602014, Press = 8.40201555665499
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8033.3491     -8033.3491     -8114.07       -8114.07        312.3982       312.3982       24080.626      24080.626      1462.2598      1462.2598    
     21000  -8033.3262     -8033.3262     -8114.7073     -8114.7073      314.95302      314.95302      24137.653      24137.653     -3119.0047     -3119.0047    
Loop time of 112.558 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.768 ns/day, 31.266 hours/ns, 8.884 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.96     | 111.96     | 111.96     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084153   | 0.084153   | 0.084153   |   0.0 |  0.07
Output  | 0.00020036 | 0.00020036 | 0.00020036 |   0.0 |  0.00
Modify  | 0.447      | 0.447      | 0.447      |   0.0 |  0.40
Other   |            | 0.06271    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116230 ave      116230 max      116230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116230
Ave neighs/atom = 58.115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.306366187247, Press = 9.21542900120601
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8033.3262     -8033.3262     -8114.7073     -8114.7073      314.95302      314.95302      24137.653      24137.653     -3119.0047     -3119.0047    
     22000  -8034.0292     -8034.0292     -8112.5653     -8112.5653      303.94272      303.94272      24133.649      24133.649     -2557.531      -2557.531     
Loop time of 112.831 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.342 hours/ns, 8.863 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.24     | 112.24     | 112.24     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083973   | 0.083973   | 0.083973   |   0.0 |  0.07
Output  | 0.00026959 | 0.00026959 | 0.00026959 |   0.0 |  0.00
Modify  | 0.44533    | 0.44533    | 0.44533    |   0.0 |  0.39
Other   |            | 0.06262    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116184 ave      116184 max      116184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116184
Ave neighs/atom = 58.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.371623464695, Press = 0.156097176680451
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8034.0292     -8034.0292     -8112.5653     -8112.5653      303.94272      303.94272      24133.649      24133.649     -2557.531      -2557.531     
     23000  -8035.2132     -8035.2132     -8115.0761     -8115.0761      309.07783      309.07783      24078.943      24078.943      1349.1555      1349.1555    
Loop time of 112.829 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.341 hours/ns, 8.863 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.23     | 112.23     | 112.23     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084162   | 0.084162   | 0.084162   |   0.0 |  0.07
Output  | 0.00016737 | 0.00016737 | 0.00016737 |   0.0 |  0.00
Modify  | 0.44716    | 0.44716    | 0.44716    |   0.0 |  0.40
Other   |            | 0.06272    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116208 ave      116208 max      116208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116208
Ave neighs/atom = 58.104
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.420673977602, Press = 3.43753878798603
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8035.2132     -8035.2132     -8115.0761     -8115.0761      309.07783      309.07783      24078.943      24078.943      1349.1555      1349.1555    
     24000  -8030.2157     -8030.2157     -8113.815      -8113.815       323.53803      323.53803      24089.563      24089.563      876.24889      876.24889    
Loop time of 112.989 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.386 hours/ns, 8.850 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.4      | 112.4      | 112.4      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082973   | 0.082973   | 0.082973   |   0.0 |  0.07
Output  | 0.00016682 | 0.00016682 | 0.00016682 |   0.0 |  0.00
Modify  | 0.44173    | 0.44173    | 0.44173    |   0.0 |  0.39
Other   |            | 0.06271    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116244 ave      116244 max      116244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116244
Ave neighs/atom = 58.122
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.586845461429, Press = 6.7504610720926
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8030.2157     -8030.2157     -8113.815      -8113.815       323.53803      323.53803      24089.563      24089.563      876.24889      876.24889    
     25000  -8032.9313     -8032.9313     -8113.4079     -8113.4079      311.45273      311.45273      24120.227      24120.227     -1597.1843     -1597.1843    
Loop time of 112.615 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.282 hours/ns, 8.880 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    | 112.02     | 112.02     | 112.02     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084395   | 0.084395   | 0.084395   |   0.0 |  0.07
Output  | 0.00017108 | 0.00017108 | 0.00017108 |   0.0 |  0.00
Modify  | 0.44412    | 0.44412    | 0.44412    |   0.0 |  0.39
Other   |            | 0.06305    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2948 ave        2948 max        2948 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116222 ave      116222 max      116222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116222
Ave neighs/atom = 58.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.680100381483, Press = 6.16486983159174
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8032.9313     -8032.9313     -8113.4079     -8113.4079      311.45273      311.45273      24120.227      24120.227     -1597.1843     -1597.1843    
     26000  -8026.6255     -8026.6255     -8108.5827     -8108.5827      317.18284      317.18284      24135.843      24135.843     -2056.8707     -2056.8707    
Loop time of 113.312 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.475 hours/ns, 8.825 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.72     | 112.72     | 112.72     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084236   | 0.084236   | 0.084236   |   0.0 |  0.07
Output  | 0.00025956 | 0.00025956 | 0.00025956 |   0.0 |  0.00
Modify  | 0.44665    | 0.44665    | 0.44665    |   0.0 |  0.39
Other   |            | 0.06243    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116206 ave      116206 max      116206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116206
Ave neighs/atom = 58.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.812380877563, Press = 1.50070176907781
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8026.6255     -8026.6255     -8108.5827     -8108.5827      317.18284      317.18284      24135.843      24135.843     -2056.8707     -2056.8707    
     27000  -8034.6404     -8034.6404     -8113.7593     -8113.7593      306.19822      306.19822      24073.181      24073.181      1923.645       1923.645     
Loop time of 109.426 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.396 hours/ns, 9.139 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    | 108.85     | 108.85     | 108.85     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08261    | 0.08261    | 0.08261    |   0.0 |  0.08
Output  | 0.00025945 | 0.00025945 | 0.00025945 |   0.0 |  0.00
Modify  | 0.42698    | 0.42698    | 0.42698    |   0.0 |  0.39
Other   |            | 0.06174    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2951 ave        2951 max        2951 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116236 ave      116236 max      116236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116236
Ave neighs/atom = 58.118
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.891763509162, Press = 1.39316348043473
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8034.6404     -8034.6404     -8113.7593     -8113.7593      306.19822      306.19822      24073.181      24073.181      1923.645       1923.645     
     28000  -8032.6456     -8032.6456     -8113.6502     -8113.6502      313.49611      313.49611      24070.122      24070.122      2205.3698      2205.3698    
Loop time of 112.051 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.771 ns/day, 31.125 hours/ns, 8.925 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.46     | 111.46     | 111.46     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083999   | 0.083999   | 0.083999   |   0.0 |  0.07
Output  | 0.00016819 | 0.00016819 | 0.00016819 |   0.0 |  0.00
Modify  | 0.44294    | 0.44294    | 0.44294    |   0.0 |  0.40
Other   |            | 0.06312    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116224 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.90931826387, Press = 5.9285939438389
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8032.6456     -8032.6456     -8113.6502     -8113.6502      313.49611      313.49611      24070.122      24070.122      2205.3698      2205.3698    
     29000  -8032.7679     -8032.7679     -8115.0925     -8115.0925      318.6047       318.6047       24117.324      24117.324     -1588.0325     -1588.0325    
Loop time of 113.098 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.416 hours/ns, 8.842 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    | 112.5      | 112.5      | 112.5      |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084858   | 0.084858   | 0.084858   |   0.0 |  0.08
Output  | 0.00016892 | 0.00016892 | 0.00016892 |   0.0 |  0.00
Modify  | 0.44971    | 0.44971    | 0.44971    |   0.0 |  0.40
Other   |            | 0.06307    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116212 ave      116212 max      116212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116212
Ave neighs/atom = 58.106
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.97266469707, Press = 5.54069731258792
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8032.7679     -8032.7679     -8115.0925     -8115.0925      318.6047       318.6047       24117.324      24117.324     -1588.0325     -1588.0325    
     30000  -8029.5514     -8029.5514     -8113.5728     -8113.5728      325.17141      325.17141      24123.8        24123.8       -1794.2953     -1794.2953    
Loop time of 113.459 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.516 hours/ns, 8.814 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    | 112.86     | 112.86     | 112.86     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084285   | 0.084285   | 0.084285   |   0.0 |  0.07
Output  | 0.00016878 | 0.00016878 | 0.00016878 |   0.0 |  0.00
Modify  | 0.44717    | 0.44717    | 0.44717    |   0.0 |  0.39
Other   |            | 0.06316    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116216 ave      116216 max      116216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116216
Ave neighs/atom = 58.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.076860589116, Press = 1.99224294200149
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8029.5514     -8029.5514     -8113.5728     -8113.5728      325.17141      325.17141      24123.8        24123.8       -1794.2953     -1794.2953    
     31000  -8034.2716     -8034.2716     -8114.8348     -8114.8348      311.78775      311.78775      24081.311      24081.311      1270.4446      1270.4446    
Loop time of 113.445 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.513 hours/ns, 8.815 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.85     | 112.85     | 112.85     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084415   | 0.084415   | 0.084415   |   0.0 |  0.07
Output  | 0.00020199 | 0.00020199 | 0.00020199 |   0.0 |  0.00
Modify  | 0.44926    | 0.44926    | 0.44926    |   0.0 |  0.40
Other   |            | 0.06458    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2947 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116224 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.197114856626, Press = 2.62385708269208
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8034.2716     -8034.2716     -8114.8348     -8114.8348      311.78775      311.78775      24081.311      24081.311      1270.4446      1270.4446    
     32000  -8029.2682     -8029.2682     -8110.1211     -8110.1211      312.90921      312.90921      24094.334      24094.334      831.45442      831.45442    
Loop time of 112.932 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.370 hours/ns, 8.855 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.33     | 112.33     | 112.33     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08509    | 0.08509    | 0.08509    |   0.0 |  0.08
Output  | 0.00021245 | 0.00021245 | 0.00021245 |   0.0 |  0.00
Modify  | 0.45008    | 0.45008    | 0.45008    |   0.0 |  0.40
Other   |            | 0.06377    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2946 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116216 ave      116216 max      116216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116216
Ave neighs/atom = 58.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.239905133373, Press = 3.96762419872153
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8029.2682     -8029.2682     -8110.1211     -8110.1211      312.90921      312.90921      24094.334      24094.334      831.45442      831.45442    
     33000  -8033.6447     -8033.6447     -8115.6419     -8115.6419      317.33779      317.33779      24107.683      24107.683     -934.58028     -934.58028    
Loop time of 112.797 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.333 hours/ns, 8.865 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.2      | 112.2      | 112.2      |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084049   | 0.084049   | 0.084049   |   0.0 |  0.07
Output  | 0.00018281 | 0.00018281 | 0.00018281 |   0.0 |  0.00
Modify  | 0.44771    | 0.44771    | 0.44771    |   0.0 |  0.40
Other   |            | 0.06266    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116224 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.275121877477, Press = 3.2910275615481
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8033.6447     -8033.6447     -8115.6419     -8115.6419      317.33779      317.33779      24107.683      24107.683     -934.58028     -934.58028    
     34000  -8031.2082     -8031.2082     -8113.4008     -8113.4008      318.09387      318.09387      24100.047      24100.047     -69.20899      -69.20899     
Loop time of 112.85 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.347 hours/ns, 8.861 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.26     | 112.26     | 112.26     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084276   | 0.084276   | 0.084276   |   0.0 |  0.07
Output  | 0.00016808 | 0.00016808 | 0.00016808 |   0.0 |  0.00
Modify  | 0.44419    | 0.44419    | 0.44419    |   0.0 |  0.39
Other   |            | 0.06297    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116166 ave      116166 max      116166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116166
Ave neighs/atom = 58.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.244108811006, Press = 2.36631452657419
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8031.2082     -8031.2082     -8113.4008     -8113.4008      318.09387      318.09387      24100.047      24100.047     -69.20899      -69.20899     
     35000  -8032.9409     -8032.9409     -8114.389      -8114.389       315.2124       315.2124       24083.414      24083.414      1140.7908      1140.7908    
Loop time of 113.022 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.395 hours/ns, 8.848 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.43     | 112.43     | 112.43     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083972   | 0.083972   | 0.083972   |   0.0 |  0.07
Output  | 0.00027304 | 0.00027304 | 0.00027304 |   0.0 |  0.00
Modify  | 0.44729    | 0.44729    | 0.44729    |   0.0 |  0.40
Other   |            | 0.06299    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116214 ave      116214 max      116214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116214
Ave neighs/atom = 58.107
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.196577543991, Press = 2.92082220480239
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8032.9409     -8032.9409     -8114.389      -8114.389       315.2124       315.2124       24083.414      24083.414      1140.7908      1140.7908    
     36000  -8031.5547     -8031.5547     -8113.959      -8113.959       318.91335      318.91335      24099.5        24099.5        8.5756545      8.5756545    
Loop time of 112.951 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.375 hours/ns, 8.853 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.35     | 112.35     | 112.35     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084126   | 0.084126   | 0.084126   |   0.0 |  0.07
Output  | 0.00016729 | 0.00016729 | 0.00016729 |   0.0 |  0.00
Modify  | 0.45099    | 0.45099    | 0.45099    |   0.0 |  0.40
Other   |            | 0.06281    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116238 ave      116238 max      116238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116238
Ave neighs/atom = 58.119
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.110704005609, Press = 3.87051658413791
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8031.5547     -8031.5547     -8113.959      -8113.959       318.91335      318.91335      24099.5        24099.5        8.5756545      8.5756545    
     37000  -8034.9354     -8034.9354     -8112.4209     -8112.4209      299.87719      299.87719      24123.378      24123.378     -1888.6704     -1888.6704    
Loop time of 113.112 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.420 hours/ns, 8.841 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    | 112.52     | 112.52     | 112.52     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084437   | 0.084437   | 0.084437   |   0.0 |  0.07
Output  | 0.00025743 | 0.00025743 | 0.00025743 |   0.0 |  0.00
Modify  | 0.44847    | 0.44847    | 0.44847    |   0.0 |  0.40
Other   |            | 0.06252    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116232 ave      116232 max      116232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116232
Ave neighs/atom = 58.116
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.116453984229, Press = 2.42129149082357
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8034.9354     -8034.9354     -8112.4209     -8112.4209      299.87719      299.87719      24123.378      24123.378     -1888.6704     -1888.6704    
     38000  -8033.7812     -8033.7812     -8113.0776     -8113.0776      306.88543      306.88543      24093.765      24093.765      418.27324      418.27324    
Loop time of 112.748 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.319 hours/ns, 8.869 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    | 112.16     | 112.16     | 112.16     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083462   | 0.083462   | 0.083462   |   0.0 |  0.07
Output  | 0.00016822 | 0.00016822 | 0.00016822 |   0.0 |  0.00
Modify  | 0.44581    | 0.44581    | 0.44581    |   0.0 |  0.40
Other   |            | 0.06264    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116206 ave      116206 max      116206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116206
Ave neighs/atom = 58.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.095185887132, Press = -0.471080606886613
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8033.7812     -8033.7812     -8113.0776     -8113.0776      306.88543      306.88543      24093.765      24093.765      418.27324      418.27324    
     39000  -8036.1176     -8036.1176     -8115.262      -8115.262       306.29714      306.29714      24045.347      24045.347      3721.8293      3721.8293    
Loop time of 112.884 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.357 hours/ns, 8.859 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.29     | 112.29     | 112.29     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083497   | 0.083497   | 0.083497   |   0.0 |  0.07
Output  | 0.00016775 | 0.00016775 | 0.00016775 |   0.0 |  0.00
Modify  | 0.44779    | 0.44779    | 0.44779    |   0.0 |  0.40
Other   |            | 0.06316    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116236 ave      116236 max      116236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116236
Ave neighs/atom = 58.118
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.131464278005, Press = 2.74037079356194
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8036.1176     -8036.1176     -8115.262      -8115.262       306.29714      306.29714      24045.347      24045.347      3721.8293      3721.8293    
     40000  -8032.0519     -8032.0519     -8113.7627     -8113.7627      316.22909      316.22909      24101.025      24101.025     -103.73917     -103.73917    
Loop time of 112.706 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.307 hours/ns, 8.873 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.11     | 112.11     | 112.11     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083439   | 0.083439   | 0.083439   |   0.0 |  0.07
Output  | 0.00023137 | 0.00023137 | 0.00023137 |   0.0 |  0.00
Modify  | 0.44592    | 0.44592    | 0.44592    |   0.0 |  0.40
Other   |            | 0.06311    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116248 ave      116248 max      116248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116248
Ave neighs/atom = 58.124
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.092713446209, Press = 3.77827618356191
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8032.0519     -8032.0519     -8113.7627     -8113.7627      316.22909      316.22909      24101.025      24101.025     -103.73917     -103.73917    
     41000  -8035.1322     -8035.1322     -8116.1616     -8116.1616      313.59212      313.59212      24118.851      24118.851     -1814.1585     -1814.1585    
Loop time of 112.859 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.350 hours/ns, 8.861 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.26     | 112.26     | 112.26     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083804   | 0.083804   | 0.083804   |   0.0 |  0.07
Output  | 0.00017014 | 0.00017014 | 0.00017014 |   0.0 |  0.00
Modify  | 0.44866    | 0.44866    | 0.44866    |   0.0 |  0.40
Other   |            | 0.06326    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116212 ave      116212 max      116212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116212
Ave neighs/atom = 58.106
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.018711305824, Press = 2.13997660858402
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8035.1322     -8035.1322     -8116.1616     -8116.1616      313.59212      313.59212      24118.851      24118.851     -1814.1585     -1814.1585    
     42000  -8031.5168     -8031.5168     -8111.7781     -8111.7781      310.6195       310.6195       24094.798      24094.798      580.15047      580.15047    
Loop time of 112.806 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.335 hours/ns, 8.865 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.21     | 112.21     | 112.21     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083581   | 0.083581   | 0.083581   |   0.0 |  0.07
Output  | 0.00016812 | 0.00016812 | 0.00016812 |   0.0 |  0.00
Modify  | 0.44953    | 0.44953    | 0.44953    |   0.0 |  0.40
Other   |            | 0.06304    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116198 ave      116198 max      116198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116198
Ave neighs/atom = 58.099
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.963066217049, Press = 0.942979739711112
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8031.5168     -8031.5168     -8111.7781     -8111.7781      310.6195       310.6195       24094.798      24094.798      580.15047      580.15047    
     43000  -8031.8035     -8031.8035     -8113.1532     -8113.1532      314.83199      314.83199      24070.367      24070.367      2217.7971      2217.7971    
Loop time of 107.496 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.860 hours/ns, 9.303 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.93     | 106.93     | 106.93     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080378   | 0.080378   | 0.080378   |   0.0 |  0.07
Output  | 0.00016825 | 0.00016825 | 0.00016825 |   0.0 |  0.00
Modify  | 0.41934    | 0.41934    | 0.41934    |   0.0 |  0.39
Other   |            | 0.0613     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116248 ave      116248 max      116248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116248
Ave neighs/atom = 58.124
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.950787430134, Press = 2.93292311837871
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8031.8035     -8031.8035     -8113.1532     -8113.1532      314.83199      314.83199      24070.367      24070.367      2217.7971      2217.7971    
     44000  -8033.4677     -8033.4677     -8112.9336     -8112.9336      307.54145      307.54145      24110.958      24110.958     -798.78683     -798.78683    
Loop time of 96.2149 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.726 hours/ns, 10.393 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.728     | 95.728     | 95.728     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072757   | 0.072757   | 0.072757   |   0.0 |  0.08
Output  | 0.00021496 | 0.00021496 | 0.00021496 |   0.0 |  0.00
Modify  | 0.35827    | 0.35827    | 0.35827    |   0.0 |  0.37
Other   |            | 0.05618    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116232 ave      116232 max      116232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116232
Ave neighs/atom = 58.116
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.020453096729, Press = 4.11728033077482
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8033.4677     -8033.4677     -8112.9336     -8112.9336      307.54145      307.54145      24110.958      24110.958     -798.78683     -798.78683    
     45000  -8028.3594     -8028.3594     -8114.0799     -8114.0799      331.74743      331.74743      24158.103      24158.103     -4372.0761     -4372.0761    
Loop time of 105 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.167 hours/ns, 9.524 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.46     | 104.46     | 104.46     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078109   | 0.078109   | 0.078109   |   0.0 |  0.07
Output  | 0.00016876 | 0.00016876 | 0.00016876 |   0.0 |  0.00
Modify  | 0.40431    | 0.40431    | 0.40431    |   0.0 |  0.39
Other   |            | 0.06006    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116234 ave      116234 max      116234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116234
Ave neighs/atom = 58.117
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.070215896596, Press = 1.20870781136659
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8028.3594     -8028.3594     -8114.0799     -8114.0799      331.74743      331.74743      24158.103      24158.103     -4372.0761     -4372.0761    
     46000  -8033.9038     -8033.9038     -8114.6591     -8114.6591      312.53162      312.53162      24088.052      24088.052      794.50757      794.50757    
Loop time of 113.048 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.402 hours/ns, 8.846 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.46     | 112.46     | 112.46     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083216   | 0.083216   | 0.083216   |   0.0 |  0.07
Output  | 0.00025454 | 0.00025454 | 0.00025454 |   0.0 |  0.00
Modify  | 0.44604    | 0.44604    | 0.44604    |   0.0 |  0.39
Other   |            | 0.06319    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116188 ave      116188 max      116188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116188
Ave neighs/atom = 58.094
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.111469994922, Press = 0.833887222972718
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8033.9038     -8033.9038     -8114.6591     -8114.6591      312.53162      312.53162      24088.052      24088.052      794.50757      794.50757    
     47000  -8036.9017     -8036.9017     -8118.1077     -8118.1077      314.27576      314.27576      24078.804      24078.804      1008.281       1008.281     
Loop time of 112.378 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.769 ns/day, 31.216 hours/ns, 8.899 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.79     | 111.79     | 111.79     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082645   | 0.082645   | 0.082645   |   0.0 |  0.07
Output  | 0.00016821 | 0.00016821 | 0.00016821 |   0.0 |  0.00
Modify  | 0.44396    | 0.44396    | 0.44396    |   0.0 |  0.40
Other   |            | 0.06352    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116210 ave      116210 max      116210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116210
Ave neighs/atom = 58.105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.110389186971, Press = 2.1989653189683
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8036.9017     -8036.9017     -8118.1077     -8118.1077      314.27576      314.27576      24078.804      24078.804      1008.281       1008.281     
     48000  -8031.9761     -8031.9761     -8113.6672     -8113.6672      316.15306      316.15306      24107.582      24107.582     -541.06805     -541.06805    
Loop time of 109.097 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.792 ns/day, 30.305 hours/ns, 9.166 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.53     | 108.53     | 108.53     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081416   | 0.081416   | 0.081416   |   0.0 |  0.07
Output  | 0.00016819 | 0.00016819 | 0.00016819 |   0.0 |  0.00
Modify  | 0.42731    | 0.42731    | 0.42731    |   0.0 |  0.39
Other   |            | 0.06226    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116204 ave      116204 max      116204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116204
Ave neighs/atom = 58.102
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.057400412227, Press = 2.98080482496901
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8031.9761     -8031.9761     -8113.6672     -8113.6672      316.15306      316.15306      24107.582      24107.582     -541.06805     -541.06805    
     49000  -8037.9541     -8037.9541     -8115.9673     -8115.9673      301.91897      301.91897      24129.81       24129.81      -2836.0429     -2836.0429    
Loop time of 96.6186 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.838 hours/ns, 10.350 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    | 96.129     | 96.129     | 96.129     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073223   | 0.073223   | 0.073223   |   0.0 |  0.08
Output  | 0.00016753 | 0.00016753 | 0.00016753 |   0.0 |  0.00
Modify  | 0.35989    | 0.35989    | 0.35989    |   0.0 |  0.37
Other   |            | 0.0567     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116190 ave      116190 max      116190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116190
Ave neighs/atom = 58.095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.013380415273, Press = 1.48638795347706
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8037.9541     -8037.9541     -8115.9673     -8115.9673      301.91897      301.91897      24129.81       24129.81      -2836.0429     -2836.0429    
     50000  -8033.0292     -8033.0292     -8116.6416     -8116.6416      323.58864      323.58864      24089.326      24089.326      592.16566      592.16566    
Loop time of 96.4676 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.797 hours/ns, 10.366 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    | 95.978     | 95.978     | 95.978     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073086   | 0.073086   | 0.073086   |   0.0 |  0.08
Output  | 0.00016811 | 0.00016811 | 0.00016811 |   0.0 |  0.00
Modify  | 0.36072    | 0.36072    | 0.36072    |   0.0 |  0.37
Other   |            | 0.05596    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116216 ave      116216 max      116216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116216
Ave neighs/atom = 58.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.018234578412, Press = -1.40289726998731
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8033.0292     -8033.0292     -8116.6416     -8116.6416      323.58864      323.58864      24089.326      24089.326      592.16566      592.16566    
     51000  -8030.9652     -8030.9652     -8111.899      -8111.899       313.22195      313.22195      24068.104      24068.104      2620.7245      2620.7245    
Loop time of 96.5556 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.821 hours/ns, 10.357 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    | 96.066     | 96.066     | 96.066     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073497   | 0.073497   | 0.073497   |   0.0 |  0.08
Output  | 0.00016778 | 0.00016778 | 0.00016778 |   0.0 |  0.00
Modify  | 0.35995    | 0.35995    | 0.35995    |   0.0 |  0.37
Other   |            | 0.0562     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116168 ave      116168 max      116168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116168
Ave neighs/atom = 58.084
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.048107363873, Press = 2.53911461191196
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8030.9652     -8030.9652     -8111.899      -8111.899       313.22195      313.22195      24068.104      24068.104      2620.7245      2620.7245    
     52000  -8030.8807     -8030.8807     -8112.0273     -8112.0273      314.04569      314.04569      24111.511      24111.511     -670.59312     -670.59312    
Loop time of 99.8232 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.866 ns/day, 27.729 hours/ns, 10.018 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    | 99.311     | 99.311     | 99.311     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075534   | 0.075534   | 0.075534   |   0.0 |  0.08
Output  | 0.00016685 | 0.00016685 | 0.00016685 |   0.0 |  0.00
Modify  | 0.37876    | 0.37876    | 0.37876    |   0.0 |  0.38
Other   |            | 0.05808    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116258 ave      116258 max      116258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116258
Ave neighs/atom = 58.129
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.124501876988, Press = 3.1188851615338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8030.8807     -8030.8807     -8112.0273     -8112.0273      314.04569      314.04569      24111.511      24111.511     -670.59312     -670.59312    
     53000  -8033.0096     -8033.0096     -8113.3021     -8113.3021      310.74033      310.74033      24129.574      24129.574     -2242.1866     -2242.1866    
Loop time of 112.802 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.334 hours/ns, 8.865 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.21     | 112.21     | 112.21     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083477   | 0.083477   | 0.083477   |   0.0 |  0.07
Output  | 0.0001714  | 0.0001714  | 0.0001714  |   0.0 |  0.00
Modify  | 0.44518    | 0.44518    | 0.44518    |   0.0 |  0.39
Other   |            | 0.06384    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116224 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.133049559255, Press = 1.51636853541877
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8033.0096     -8033.0096     -8113.3021     -8113.3021      310.74033      310.74033      24129.574      24129.574     -2242.1866     -2242.1866    
     54000  -8029.9791     -8029.9791     -8110.9788     -8110.9788      313.47704      313.47704      24096.906      24096.906      582.64944      582.64944    
Loop time of 112.853 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.348 hours/ns, 8.861 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.26     | 112.26     | 112.26     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084009   | 0.084009   | 0.084009   |   0.0 |  0.07
Output  | 0.00027328 | 0.00027328 | 0.00027328 |   0.0 |  0.00
Modify  | 0.4488     | 0.4488     | 0.4488     |   0.0 |  0.40
Other   |            | 0.06417    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116196 ave      116196 max      116196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116196
Ave neighs/atom = 58.098
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.196645925953, Press = 0.977745244873179
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8029.9791     -8029.9791     -8110.9788     -8110.9788      313.47704      313.47704      24096.906      24096.906      582.64944      582.64944    
     55000  -8030.5707     -8030.5707     -8112.7567     -8112.7567      318.06799      318.06799      24070.916      24070.916      2319.4009      2319.4009    
Loop time of 113.041 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.400 hours/ns, 8.846 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.45     | 112.45     | 112.45     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083488   | 0.083488   | 0.083488   |   0.0 |  0.07
Output  | 0.0001701  | 0.0001701  | 0.0001701  |   0.0 |  0.00
Modify  | 0.44639    | 0.44639    | 0.44639    |   0.0 |  0.39
Other   |            | 0.0638     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116256 ave      116256 max      116256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116256
Ave neighs/atom = 58.128
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.196780434859, Press = 2.25225620665647
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8030.5707     -8030.5707     -8112.7567     -8112.7567      318.06799      318.06799      24070.916      24070.916      2319.4009      2319.4009    
     56000  -8036.2908     -8036.2908     -8115.24       -8115.24        305.54151      305.54151      24103.866      24103.866     -533.71015     -533.71015    
Loop time of 112.992 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.387 hours/ns, 8.850 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.4      | 112.4      | 112.4      |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083624   | 0.083624   | 0.083624   |   0.0 |  0.07
Output  | 0.00021813 | 0.00021813 | 0.00021813 |   0.0 |  0.00
Modify  | 0.44704    | 0.44704    | 0.44704    |   0.0 |  0.40
Other   |            | 0.06359    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2947 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116242 ave      116242 max      116242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116242
Ave neighs/atom = 58.121
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.164544202403, Press = 4.17717661753793
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8036.2908     -8036.2908     -8115.24       -8115.24        305.54151      305.54151      24103.866      24103.866     -533.71015     -533.71015    
     57000  -8032.1098     -8032.1098     -8112.3786     -8112.3786      310.64876      310.64876      24141.839      24141.839     -3097.3955     -3097.3955    
Loop time of 113.075 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.410 hours/ns, 8.844 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.48     | 112.48     | 112.48     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083746   | 0.083746   | 0.083746   |   0.0 |  0.07
Output  | 0.00023062 | 0.00023062 | 0.00023062 |   0.0 |  0.00
Modify  | 0.4457     | 0.4457     | 0.4457     |   0.0 |  0.39
Other   |            | 0.06358    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116206 ave      116206 max      116206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116206
Ave neighs/atom = 58.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.127428071836, Press = 1.53949187889922
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -8032.1098     -8032.1098     -8112.3786     -8112.3786      310.64876      310.64876      24141.839      24141.839     -3097.3955     -3097.3955    
     58000  -8032.3151     -8032.3151     -8113.5551     -8113.5551      314.40738      314.40738      24090.558      24090.558      853.06976      853.06976    
Loop time of 113.105 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.418 hours/ns, 8.841 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.51     | 112.51     | 112.51     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083818   | 0.083818   | 0.083818   |   0.0 |  0.07
Output  | 0.00020945 | 0.00020945 | 0.00020945 |   0.0 |  0.00
Modify  | 0.4483     | 0.4483     | 0.4483     |   0.0 |  0.40
Other   |            | 0.063      |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116170 ave      116170 max      116170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116170
Ave neighs/atom = 58.085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.110960085973, Press = 1.07877646962781
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -8032.3151     -8032.3151     -8113.5551     -8113.5551      314.40738      314.40738      24090.558      24090.558      853.06976      853.06976    
     59000  -8033.2807     -8033.2807     -8115.7205     -8115.7205      319.05056      319.05056      24081.726      24081.726      1131.6592      1131.6592    
Loop time of 112.852 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.348 hours/ns, 8.861 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.26     | 112.26     | 112.26     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083752   | 0.083752   | 0.083752   |   0.0 |  0.07
Output  | 0.00022112 | 0.00022112 | 0.00022112 |   0.0 |  0.00
Modify  | 0.44833    | 0.44833    | 0.44833    |   0.0 |  0.40
Other   |            | 0.06305    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116208 ave      116208 max      116208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116208
Ave neighs/atom = 58.104
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.155392542366, Press = 2.16472441254093
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8033.2807     -8033.2807     -8115.7205     -8115.7205      319.05056      319.05056      24081.726      24081.726      1131.6592      1131.6592    
     60000  -8030.1516     -8030.1516     -8113.2668     -8113.2668      321.66473      321.66473      24110.291      24110.291     -714.88413     -714.88413    
Loop time of 112.798 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.333 hours/ns, 8.865 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.2      | 112.2      | 112.2      |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084205   | 0.084205   | 0.084205   |   0.0 |  0.07
Output  | 0.00017073 | 0.00017073 | 0.00017073 |   0.0 |  0.00
Modify  | 0.44601    | 0.44601    | 0.44601    |   0.0 |  0.40
Other   |            | 0.06305    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116228 ave      116228 max      116228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116228
Ave neighs/atom = 58.114
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.165320198152, Press = 2.32171797287163
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -8030.1516     -8030.1516     -8113.2668     -8113.2668      321.66473      321.66473      24110.291      24110.291     -714.88413     -714.88413    
     61000  -8032.4634     -8032.4634     -8113.0152     -8113.0152      311.74377      311.74377      24115.578      24115.578     -1245.6275     -1245.6275    
Loop time of 112.832 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.342 hours/ns, 8.863 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.24     | 112.24     | 112.24     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08523    | 0.08523    | 0.08523    |   0.0 |  0.08
Output  | 0.00023216 | 0.00023216 | 0.00023216 |   0.0 |  0.00
Modify  | 0.44601    | 0.44601    | 0.44601    |   0.0 |  0.40
Other   |            | 0.06329    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2948 ave        2948 max        2948 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116182 ave      116182 max      116182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116182
Ave neighs/atom = 58.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.229938553482, Press = 0.941161162412551
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -8032.4634     -8032.4634     -8113.0152     -8113.0152      311.74377      311.74377      24115.578      24115.578     -1245.6275     -1245.6275    
     62000  -8032.255      -8032.255      -8114.5531     -8114.5531      318.50206      318.50206      24074.338      24074.338      1825.2304      1825.2304    
Loop time of 108.436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.797 ns/day, 30.121 hours/ns, 9.222 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.87     | 107.87     | 107.87     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080363   | 0.080363   | 0.080363   |   0.0 |  0.07
Output  | 0.00017    | 0.00017    | 0.00017    |   0.0 |  0.00
Modify  | 0.42512    | 0.42512    | 0.42512    |   0.0 |  0.39
Other   |            | 0.06183    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116256 ave      116256 max      116256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116256
Ave neighs/atom = 58.128
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.251327189271, Press = 0.775386779310792
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -8032.255      -8032.255      -8114.5531     -8114.5531      318.50206      318.50206      24074.338      24074.338      1825.2304      1825.2304    
     63000  -8035.9592     -8035.9592     -8115.67       -8115.67        308.4891       308.4891       24057.094      24057.094      2922.6585      2922.6585    
Loop time of 96.9409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.891 ns/day, 26.928 hours/ns, 10.316 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.449     | 96.449     | 96.449     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073548   | 0.073548   | 0.073548   |   0.0 |  0.08
Output  | 0.00016962 | 0.00016962 | 0.00016962 |   0.0 |  0.00
Modify  | 0.36149    | 0.36149    | 0.36149    |   0.0 |  0.37
Other   |            | 0.05702    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2946 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116224 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.267537160309, Press = 2.84736046621806
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -8035.9592     -8035.9592     -8115.67       -8115.67        308.4891       308.4891       24057.094      24057.094      2922.6585      2922.6585    
     64000  -8032.3725     -8032.3725     -8111.1727     -8111.1727      304.96504      304.96504      24129.159      24129.159     -2122.5079     -2122.5079    
Loop time of 96.394 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.776 hours/ns, 10.374 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    | 95.902     | 95.902     | 95.902     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073373   | 0.073373   | 0.073373   |   0.0 |  0.08
Output  | 0.00016925 | 0.00016925 | 0.00016925 |   0.0 |  0.00
Modify  | 0.36134    | 0.36134    | 0.36134    |   0.0 |  0.37
Other   |            | 0.0576     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116240 ave      116240 max      116240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116240
Ave neighs/atom = 58.12
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.265215606905, Press = 2.53455369535771
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -8032.3725     -8032.3725     -8111.1727     -8111.1727      304.96504      304.96504      24129.159      24129.159     -2122.5079     -2122.5079    
     65000  -8034.4876     -8034.4876     -8116.2476     -8116.2476      316.41965      316.41965      24121.541      24121.541     -1984.1639     -1984.1639    
Loop time of 96.868 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.908 hours/ns, 10.323 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    | 96.376     | 96.376     | 96.376     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073704   | 0.073704   | 0.073704   |   0.0 |  0.08
Output  | 0.00016805 | 0.00016805 | 0.00016805 |   0.0 |  0.00
Modify  | 0.36157    | 0.36157    | 0.36157    |   0.0 |  0.37
Other   |            | 0.05665    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116210 ave      116210 max      116210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116210
Ave neighs/atom = 58.105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.257477848523, Press = 0.680654642144151
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -8034.4876     -8034.4876     -8116.2476     -8116.2476      316.41965      316.41965      24121.541      24121.541     -1984.1639     -1984.1639    
     66000  -8029.2041     -8029.2041     -8110.7063     -8110.7063      315.42172      315.42172      24075.518      24075.518      2176.1547      2176.1547    
Loop time of 96.7633 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.879 hours/ns, 10.334 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    | 96.271     | 96.271     | 96.271     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072944   | 0.072944   | 0.072944   |   0.0 |  0.08
Output  | 0.00017051 | 0.00017051 | 0.00017051 |   0.0 |  0.00
Modify  | 0.3624     | 0.3624     | 0.3624     |   0.0 |  0.37
Other   |            | 0.05707    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116176 ave      116176 max      116176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116176
Ave neighs/atom = 58.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.262132673872, Press = 1.12541398210002
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -8029.2041     -8029.2041     -8110.7063     -8110.7063      315.42172      315.42172      24075.518      24075.518      2176.1547      2176.1547    
     67000  -8032.0906     -8032.0906     -8112.0714     -8112.0714      309.53377      309.53377      24084.482      24084.482      1340.2872      1340.2872    
Loop time of 96.6986 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.861 hours/ns, 10.341 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    | 96.206     | 96.206     | 96.206     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073635   | 0.073635   | 0.073635   |   0.0 |  0.08
Output  | 0.00016908 | 0.00016908 | 0.00016908 |   0.0 |  0.00
Modify  | 0.36079    | 0.36079    | 0.36079    |   0.0 |  0.37
Other   |            | 0.05764    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116268 ave      116268 max      116268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116268
Ave neighs/atom = 58.134
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.265218619511, Press = 2.20532696803916
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -8032.0906     -8032.0906     -8112.0714     -8112.0714      309.53377      309.53377      24084.482      24084.482      1340.2872      1340.2872    
     68000  -8034.24       -8034.24       -8113.9363     -8113.9363      308.43297      308.43297      24101.078      24101.078     -86.057501     -86.057501    
Loop time of 96.7683 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.880 hours/ns, 10.334 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    | 96.277     | 96.277     | 96.277     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073788   | 0.073788   | 0.073788   |   0.0 |  0.08
Output  | 0.00016796 | 0.00016796 | 0.00016796 |   0.0 |  0.00
Modify  | 0.36034    | 0.36034    | 0.36034    |   0.0 |  0.37
Other   |            | 0.05724    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116236 ave      116236 max      116236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116236
Ave neighs/atom = 58.118
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.255922105181, Press = 1.7469365454451
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -8034.24       -8034.24       -8113.9363     -8113.9363      308.43297      308.43297      24101.078      24101.078     -86.057501     -86.057501    
     69000  -8034.7589     -8034.7589     -8115.9308     -8115.9308      314.14375      314.14375      24103.856      24103.856     -651.82738     -651.82738    
Loop time of 96.9268 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.891 ns/day, 26.924 hours/ns, 10.317 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    | 96.437     | 96.437     | 96.437     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073753   | 0.073753   | 0.073753   |   0.0 |  0.08
Output  | 0.00020435 | 0.00020435 | 0.00020435 |   0.0 |  0.00
Modify  | 0.35941    | 0.35941    | 0.35941    |   0.0 |  0.37
Other   |            | 0.05677    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116238 ave      116238 max      116238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116238
Ave neighs/atom = 58.119
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.202571501217, Press = 1.31288213011324
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -8034.7589     -8034.7589     -8115.9308     -8115.9308      314.14375      314.14375      24103.856      24103.856     -651.82738     -651.82738    
     70000  -8031.6191     -8031.6191     -8111.914      -8111.914       310.74952      310.74952      24096.663      24096.663      342.31917      342.31917    
Loop time of 96.8284 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.897 hours/ns, 10.328 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    | 96.336     | 96.336     | 96.336     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073657   | 0.073657   | 0.073657   |   0.0 |  0.08
Output  | 0.0001685  | 0.0001685  | 0.0001685  |   0.0 |  0.00
Modify  | 0.36178    | 0.36178    | 0.36178    |   0.0 |  0.37
Other   |            | 0.05701    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116216 ave      116216 max      116216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116216
Ave neighs/atom = 58.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.184558453094, Press = 1.26648458388004
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -8031.6191     -8031.6191     -8111.914      -8111.914       310.74952      310.74952      24096.663      24096.663      342.31917      342.31917    
     71000  -8033.3935     -8033.3935     -8114.2491     -8114.2491      312.9197       312.9197       24091.377      24091.377      568.3961       568.3961     
Loop time of 96.6547 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.849 hours/ns, 10.346 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    | 96.162     | 96.162     | 96.162     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074029   | 0.074029   | 0.074029   |   0.0 |  0.08
Output  | 0.00017068 | 0.00017068 | 0.00017068 |   0.0 |  0.00
Modify  | 0.3611     | 0.3611     | 0.3611     |   0.0 |  0.37
Other   |            | 0.05763    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116264 ave      116264 max      116264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116264
Ave neighs/atom = 58.132
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.191029178798, Press = 1.62457759682303
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -8033.3935     -8033.3935     -8114.2491     -8114.2491      312.9197       312.9197       24091.377      24091.377      568.3961       568.3961     
     72000  -8029.2999     -8029.2999     -8112.931      -8112.931       323.66082      323.66082      24109.34       24109.34      -676.96423     -676.96423    
Loop time of 96.6323 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.842 hours/ns, 10.349 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    | 96.14      | 96.14      | 96.14      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074009   | 0.074009   | 0.074009   |   0.0 |  0.08
Output  | 0.0001692  | 0.0001692  | 0.0001692  |   0.0 |  0.00
Modify  | 0.36106    | 0.36106    | 0.36106    |   0.0 |  0.37
Other   |            | 0.05736    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2947 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116196 ave      116196 max      116196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116196
Ave neighs/atom = 58.098
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.230601523359, Press = 1.38759063494938
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -8029.2999     -8029.2999     -8112.931      -8112.931       323.66082      323.66082      24109.34       24109.34      -676.96423     -676.96423    
     73000  -8035.1408     -8035.1408     -8113.0307     -8113.0307      301.44196      301.44196      24096.311      24096.311      256.64238      256.64238    
Loop time of 111.654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.774 ns/day, 31.015 hours/ns, 8.956 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.07     | 111.07     | 111.07     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083125   | 0.083125   | 0.083125   |   0.0 |  0.07
Output  | 0.00016902 | 0.00016902 | 0.00016902 |   0.0 |  0.00
Modify  | 0.43823    | 0.43823    | 0.43823    |   0.0 |  0.39
Other   |            | 0.06306    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2949 ave        2949 max        2949 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116228 ave      116228 max      116228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116228
Ave neighs/atom = 58.114
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.23859093913, Press = 1.03546111578341
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -8035.1408     -8035.1408     -8113.0307     -8113.0307      301.44196      301.44196      24096.311      24096.311      256.64238      256.64238    
     74000  -8033.7501     -8033.7501     -8114.103      -8114.103       310.97409      310.97409      24080.491      24080.491      1429.9076      1429.9076    
Loop time of 112.607 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.280 hours/ns, 8.880 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.01     | 112.01     | 112.01     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083922   | 0.083922   | 0.083922   |   0.0 |  0.07
Output  | 0.00016803 | 0.00016803 | 0.00016803 |   0.0 |  0.00
Modify  | 0.44526    | 0.44526    | 0.44526    |   0.0 |  0.40
Other   |            | 0.06332    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2946 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116244 ave      116244 max      116244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116244
Ave neighs/atom = 58.122
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.263918428014, Press = 1.24560903822647
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -8033.7501     -8033.7501     -8114.103      -8114.103       310.97409      310.97409      24080.491      24080.491      1429.9076      1429.9076    
     75000  -8035.0595     -8035.0595     -8114.8083     -8114.8083      308.63598      308.63598      24090.55       24090.55       453.47986      453.47986    
Loop time of 112.663 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.295 hours/ns, 8.876 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.07     | 112.07     | 112.07     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083932   | 0.083932   | 0.083932   |   0.0 |  0.07
Output  | 0.00016942 | 0.00016942 | 0.00016942 |   0.0 |  0.00
Modify  | 0.44761    | 0.44761    | 0.44761    |   0.0 |  0.40
Other   |            | 0.06344    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116184 ave      116184 max      116184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116184
Ave neighs/atom = 58.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.286851412287, Press = 2.07290555266994
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -8035.0595     -8035.0595     -8114.8083     -8114.8083      308.63598      308.63598      24090.55       24090.55       453.47986      453.47986    
     76000  -8028.8282     -8028.8282     -8111.644      -8111.644       320.50551      320.50551      24140.33       24140.33      -2798.4549     -2798.4549    
Loop time of 112.669 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.297 hours/ns, 8.876 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.07     | 112.07     | 112.07     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084578   | 0.084578   | 0.084578   |   0.0 |  0.08
Output  | 0.00016915 | 0.00016915 | 0.00016915 |   0.0 |  0.00
Modify  | 0.4486     | 0.4486     | 0.4486     |   0.0 |  0.40
Other   |            | 0.06306    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116222 ave      116222 max      116222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116222
Ave neighs/atom = 58.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.297029561519, Press = 1.40713138688105
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -8028.8282     -8028.8282     -8111.644      -8111.644       320.50551      320.50551      24140.33       24140.33      -2798.4549     -2798.4549    
     77000  -8033.5143     -8033.5143     -8113.7838     -8113.7838      310.65136      310.65136      24117.673      24117.673     -1504.7997     -1504.7997    
Loop time of 112.61 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.281 hours/ns, 8.880 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.01     | 112.01     | 112.01     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08495    | 0.08495    | 0.08495    |   0.0 |  0.08
Output  | 0.00017047 | 0.00017047 | 0.00017047 |   0.0 |  0.00
Modify  | 0.45219    | 0.45219    | 0.45219    |   0.0 |  0.40
Other   |            | 0.06341    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2946 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116206 ave      116206 max      116206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116206
Ave neighs/atom = 58.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
24099.0440845146

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0