# 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.880978018045426*${_u_distance}
variable latticeconst_converted equal 2.880978018045426*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.88097801804543
Lattice spacing in x,y,z = 2.880978 2.880978 2.880978
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.80978 28.80978 28.80978)
  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.80978 28.80978 28.80978)
  create_atoms CPU = 0.000 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_ChoiKimSeol_2017_CoCr__MO_410167849923_002
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.2164838903    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23912.2164838903/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23912.2164838903/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23912.2164838903/(1*1*${_u_distance})
variable      V0_metal equal 23912.2164838903/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23912.2164838903*1000

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8119.0849     -8119.0849     -8200          -8200           313.15         313.15         23912.216      23912.216      3614.3302      3614.3302    
      1000  -8034.7316     -8034.7316     -8116.9191     -8116.9191      318.07431      318.07431      24192.555      24192.555     -939.11626     -939.11626    
Loop time of 15.3204 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.640 ns/day, 4.256 hours/ns, 65.272 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 15.239     | 15.239     | 15.239     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015379   | 0.015379   | 0.015379   |   0.0 |  0.10
Output  | 0.00017208 | 0.00017208 | 0.00017208 |   0.0 |  0.00
Modify  | 0.060551   | 0.060551   | 0.060551   |   0.0 |  0.40
Other   |            | 0.005784   |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8034.7316     -8034.7316     -8116.9191     -8116.9191      318.07431      318.07431      24192.555      24192.555     -939.11626     -939.11626    
      2000  -8034.3447     -8034.3447     -8118.9608     -8118.9608      327.47303      327.47303      24196.98       24196.98      -1582.3735     -1582.3735    
Loop time of 17.4987 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.938 ns/day, 4.861 hours/ns, 57.147 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.419     | 17.419     | 17.419     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014925   | 0.014925   | 0.014925   |   0.0 |  0.09
Output  | 5.4172e-05 | 5.4172e-05 | 5.4172e-05 |   0.0 |  0.00
Modify  | 0.059577   | 0.059577   | 0.059577   |   0.0 |  0.34
Other   |            | 0.005525   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127944 ave      127944 max      127944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8034.3447     -8034.3447     -8118.9608     -8118.9608      327.47303      327.47303      24196.98       24196.98      -1582.3735     -1582.3735    
      3000  -8036.7986     -8036.7986     -8119.7713     -8119.7713      321.11318      321.11318      24178.976      24178.976     -506.68977     -506.68977    
Loop time of 17.6559 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.894 ns/day, 4.904 hours/ns, 56.638 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.575     | 17.575     | 17.575     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015058   | 0.015058   | 0.015058   |   0.0 |  0.09
Output  | 5.318e-05  | 5.318e-05  | 5.318e-05  |   0.0 |  0.00
Modify  | 0.059942   | 0.059942   | 0.059942   |   0.0 |  0.34
Other   |            | 0.005424   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127964 ave      127964 max      127964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127964
Ave neighs/atom = 63.982
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8036.7986     -8036.7986     -8119.7713     -8119.7713      321.11318      321.11318      24178.976      24178.976     -506.68977     -506.68977    
      4000  -8033.2415     -8033.2415     -8119.0169     -8119.0169      331.95952      331.95952      24178.751      24178.751     -451.01172     -451.01172    
Loop time of 17.7487 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.868 ns/day, 4.930 hours/ns, 56.342 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.669     | 17.669     | 17.669     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014981   | 0.014981   | 0.014981   |   0.0 |  0.08
Output  | 3.3292e-05 | 3.3292e-05 | 3.3292e-05 |   0.0 |  0.00
Modify  | 0.059539   | 0.059539   | 0.059539   |   0.0 |  0.34
Other   |            | 0.005373   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127942 ave      127942 max      127942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8033.2415     -8033.2415     -8119.0169     -8119.0169      331.95952      331.95952      24178.751      24178.751     -451.01172     -451.01172    
      5000  -8037.8415     -8037.8415     -8116.7136     -8116.7136      305.24302      305.24302      24165.256      24165.256      1124.7682      1124.7682    
Loop time of 17.7856 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.858 ns/day, 4.940 hours/ns, 56.225 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.705     | 17.705     | 17.705     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014933   | 0.014933   | 0.014933   |   0.0 |  0.08
Output  | 2.3104e-05 | 2.3104e-05 | 2.3104e-05 |   0.0 |  0.00
Modify  | 0.059814   | 0.059814   | 0.059814   |   0.0 |  0.34
Other   |            | 0.005386   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127944 ave      127944 max      127944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.786245159494, Press = 62.1612164009776
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8037.8415     -8037.8415     -8116.7136     -8116.7136      305.24302      305.24302      24165.256      24165.256      1124.7682      1124.7682    
      6000  -8034.5199     -8034.5199     -8117.4716     -8117.4716      321.03156      321.03156      24203.412      24203.412     -2259.4104     -2259.4104    
Loop time of 17.7807 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.859 ns/day, 4.939 hours/ns, 56.241 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.698     | 17.698     | 17.698     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015003   | 0.015003   | 0.015003   |   0.0 |  0.08
Output  | 4.2469e-05 | 4.2469e-05 | 4.2469e-05 |   0.0 |  0.00
Modify  | 0.062029   | 0.062029   | 0.062029   |   0.0 |  0.35
Other   |            | 0.005404   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127948 ave      127948 max      127948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127948
Ave neighs/atom = 63.974
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.542315219399, Press = -2.22758966250275
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8034.5199     -8034.5199     -8117.4716     -8117.4716      321.03156      321.03156      24203.412      24203.412     -2259.4104     -2259.4104    
      7000  -8036.1811     -8036.1811     -8114.7359     -8114.7359      304.0151       304.0151       24184.276      24184.276     -252.3367      -252.3367     
Loop time of 17.8002 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.854 ns/day, 4.945 hours/ns, 56.179 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.718     | 17.718     | 17.718     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014972   | 0.014972   | 0.014972   |   0.0 |  0.08
Output  | 2.4526e-05 | 2.4526e-05 | 2.4526e-05 |   0.0 |  0.00
Modify  | 0.06195    | 0.06195    | 0.06195    |   0.0 |  0.35
Other   |            | 0.005424   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127938 ave      127938 max      127938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.244195875539, Press = -11.3935298319302
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8036.1811     -8036.1811     -8114.7359     -8114.7359      304.0151       304.0151       24184.276      24184.276     -252.3367      -252.3367     
      8000  -8036.5388     -8036.5388     -8117.0829     -8117.0829      311.71405      311.71405      24156.754      24156.754      1349.8969      1349.8969    
Loop time of 17.822 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.848 ns/day, 4.951 hours/ns, 56.110 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.74      | 17.74      | 17.74      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014921   | 0.014921   | 0.014921   |   0.0 |  0.08
Output  | 2.3594e-05 | 2.3594e-05 | 2.3594e-05 |   0.0 |  0.00
Modify  | 0.062098   | 0.062098   | 0.062098   |   0.0 |  0.35
Other   |            | 0.005419   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127950 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127950
Ave neighs/atom = 63.975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.940474826141, Press = -11.1927515965896
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8036.5388     -8036.5388     -8117.0829     -8117.0829      311.71405      311.71405      24156.754      24156.754      1349.8969      1349.8969    
      9000  -8034.8399     -8034.8399     -8115.7997     -8115.7997      313.32301      313.32301      24183.118      24183.118     -350.24802     -350.24802    
Loop time of 17.8126 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.851 ns/day, 4.948 hours/ns, 56.140 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.73      | 17.73      | 17.73      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014921   | 0.014921   | 0.014921   |   0.0 |  0.08
Output  | 4.222e-05  | 4.222e-05  | 4.222e-05  |   0.0 |  0.00
Modify  | 0.061958   | 0.061958   | 0.061958   |   0.0 |  0.35
Other   |            | 0.005446   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127938 ave      127938 max      127938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.753920902866, Press = 10.4974920662101
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8034.8399     -8034.8399     -8115.7997     -8115.7997      313.32301      313.32301      24183.118      24183.118     -350.24802     -350.24802    
     10000  -8038.7257     -8038.7257     -8120.7642     -8120.7642      317.49734      317.49734      24205.292      24205.292     -3030.5471     -3030.5471    
Loop time of 17.8178 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.849 ns/day, 4.949 hours/ns, 56.124 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.735     | 17.735     | 17.735     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014959   | 0.014959   | 0.014959   |   0.0 |  0.08
Output  | 2.4576e-05 | 2.4576e-05 | 2.4576e-05 |   0.0 |  0.00
Modify  | 0.06199    | 0.06199    | 0.06199    |   0.0 |  0.35
Other   |            | 0.005408   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127914 ave      127914 max      127914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127914
Ave neighs/atom = 63.957
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.667496996913, Press = -13.0149258519227
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8038.7257     -8038.7257     -8120.7642     -8120.7642      317.49734      317.49734      24205.292      24205.292     -3030.5471     -3030.5471    
     11000  -8034.754      -8034.754      -8114.2764     -8114.2764      307.75978      307.75978      24147.34       24147.34       2870.2755      2870.2755    
Loop time of 17.8239 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.847 ns/day, 4.951 hours/ns, 56.104 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.742     | 17.742     | 17.742     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015015   | 0.015015   | 0.015015   |   0.0 |  0.08
Output  | 2.3314e-05 | 2.3314e-05 | 2.3314e-05 |   0.0 |  0.00
Modify  | 0.061968   | 0.061968   | 0.061968   |   0.0 |  0.35
Other   |            | 0.005423   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127932 ave      127932 max      127932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127932
Ave neighs/atom = 63.966
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.58868724949, Press = -8.96108477945214
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8034.754      -8034.754      -8114.2764     -8114.2764      307.75978      307.75978      24147.34       24147.34       2870.2755      2870.2755    
     12000  -8034.9581     -8034.9581     -8116.5261     -8116.5261      315.67679      315.67679      24165.225      24165.225      1281.7336      1281.7336    
Loop time of 17.8517 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.840 ns/day, 4.959 hours/ns, 56.017 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.769     | 17.769     | 17.769     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015009   | 0.015009   | 0.015009   |   0.0 |  0.08
Output  | 3.8402e-05 | 3.8402e-05 | 3.8402e-05 |   0.0 |  0.00
Modify  | 0.062228   | 0.062228   | 0.062228   |   0.0 |  0.35
Other   |            | 0.005436   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127924 ave      127924 max      127924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127924
Ave neighs/atom = 63.962
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.746899804191, Press = 6.20571427563311
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8034.9581     -8034.9581     -8116.5261     -8116.5261      315.67679      315.67679      24165.225      24165.225      1281.7336      1281.7336    
     13000  -8034.672      -8034.672      -8115.5111     -8115.5111      312.85578      312.85578      24195.59       24195.59      -1233.4493     -1233.4493    
Loop time of 17.8486 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.841 ns/day, 4.958 hours/ns, 56.027 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.766     | 17.766     | 17.766     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014984   | 0.014984   | 0.014984   |   0.0 |  0.08
Output  | 2.4416e-05 | 2.4416e-05 | 2.4416e-05 |   0.0 |  0.00
Modify  | 0.061925   | 0.061925   | 0.061925   |   0.0 |  0.35
Other   |            | 0.005457   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127930 ave      127930 max      127930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127930
Ave neighs/atom = 63.965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.213529405752, Press = -2.94428531960834
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8034.672      -8034.672      -8115.5111     -8115.5111      312.85578      312.85578      24195.59       24195.59      -1233.4493     -1233.4493    
     14000  -8035.2707     -8035.2707     -8116.1752     -8116.1752      313.10898      313.10898      24170.824      24170.824      786.166        786.166      
Loop time of 17.852 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.840 ns/day, 4.959 hours/ns, 56.016 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.77      | 17.77      | 17.77      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015045   | 0.015045   | 0.015045   |   0.0 |  0.08
Output  | 5.5504e-05 | 5.5504e-05 | 5.5504e-05 |   0.0 |  0.00
Modify  | 0.061996   | 0.061996   | 0.061996   |   0.0 |  0.35
Other   |            | 0.005402   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127920 ave      127920 max      127920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127920
Ave neighs/atom = 63.96
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.299095990439, Press = -2.60638835691574
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8035.2707     -8035.2707     -8116.1752     -8116.1752      313.10898      313.10898      24170.824      24170.824      786.166        786.166      
     15000  -8034.9472     -8034.9472     -8113.548      -8113.548       304.19346      304.19346      24173.495      24173.495      886.02541      886.02541    
Loop time of 17.8029 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.853 ns/day, 4.945 hours/ns, 56.171 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.72      | 17.72      | 17.72      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015032   | 0.015032   | 0.015032   |   0.0 |  0.08
Output  | 2.3835e-05 | 2.3835e-05 | 2.3835e-05 |   0.0 |  0.00
Modify  | 0.062059   | 0.062059   | 0.062059   |   0.0 |  0.35
Other   |            | 0.005414   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127938 ave      127938 max      127938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.36730530074, Press = -0.810101432442489
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8034.9472     -8034.9472     -8113.548      -8113.548       304.19346      304.19346      24173.495      24173.495      886.02541      886.02541    
     16000  -8034.4441     -8034.4441     -8116.2114     -8116.2114      316.44792      316.44792      24207.721      24207.721     -2294.9646     -2294.9646    
Loop time of 17.8369 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.844 ns/day, 4.955 hours/ns, 56.063 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.754     | 17.754     | 17.754     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015091   | 0.015091   | 0.015091   |   0.0 |  0.08
Output  | 4.1909e-05 | 4.1909e-05 | 4.1909e-05 |   0.0 |  0.00
Modify  | 0.062054   | 0.062054   | 0.062054   |   0.0 |  0.35
Other   |            | 0.005415   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127950 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127950
Ave neighs/atom = 63.975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.406893565207, Press = -2.325830257977
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8034.4441     -8034.4441     -8116.2114     -8116.2114      316.44792      316.44792      24207.721      24207.721     -2294.9646     -2294.9646    
     17000  -8036.6688     -8036.6688     -8115.3562     -8115.3562      304.52837      304.52837      24167.306      24167.306      1041.46        1041.46      
Loop time of 17.8507 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.840 ns/day, 4.959 hours/ns, 56.020 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.768     | 17.768     | 17.768     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015042   | 0.015042   | 0.015042   |   0.0 |  0.08
Output  | 2.5007e-05 | 2.5007e-05 | 2.5007e-05 |   0.0 |  0.00
Modify  | 0.062106   | 0.062106   | 0.062106   |   0.0 |  0.35
Other   |            | 0.005425   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127950 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127950
Ave neighs/atom = 63.975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.582012973699, Press = -7.34064268218725
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8036.6688     -8036.6688     -8115.3562     -8115.3562      304.52837      304.52837      24167.306      24167.306      1041.46        1041.46      
     18000  -8031.9639     -8031.9639     -8116.9907     -8116.9907      329.06246      329.06246      24148.802      24148.802      2263.5413      2263.5413    
Loop time of 17.9001 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.827 ns/day, 4.972 hours/ns, 55.866 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.818     | 17.818     | 17.818     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015044   | 0.015044   | 0.015044   |   0.0 |  0.08
Output  | 2.3644e-05 | 2.3644e-05 | 2.3644e-05 |   0.0 |  0.00
Modify  | 0.061927   | 0.061927   | 0.061927   |   0.0 |  0.35
Other   |            | 0.005425   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127940 ave      127940 max      127940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127940
Ave neighs/atom = 63.97
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.799316824522, Press = 1.25100693042886
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8031.9639     -8031.9639     -8116.9907     -8116.9907      329.06246      329.06246      24148.802      24148.802      2263.5413      2263.5413    
     19000  -8035.0201     -8035.0201     -8115.46       -8115.46        311.3109       311.3109       24205.433      24205.433     -1894.5955     -1894.5955    
Loop time of 17.9205 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.821 ns/day, 4.978 hours/ns, 55.802 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.838     | 17.838     | 17.838     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015082   | 0.015082   | 0.015082   |   0.0 |  0.08
Output  | 4.4103e-05 | 4.4103e-05 | 4.4103e-05 |   0.0 |  0.00
Modify  | 0.06203    | 0.06203    | 0.06203    |   0.0 |  0.35
Other   |            | 0.005435   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127944 ave      127944 max      127944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.037352578698, Press = 1.24188428435265
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8035.0201     -8035.0201     -8115.46       -8115.46        311.3109       311.3109       24205.433      24205.433     -1894.5955     -1894.5955    
     20000  -8034.4777     -8034.4777     -8116.5029     -8116.5029      317.44591      317.44591      24186.128      24186.128     -710.47013     -710.47013    
Loop time of 17.8193 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.849 ns/day, 4.950 hours/ns, 56.119 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.737     | 17.737     | 17.737     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01493    | 0.01493    | 0.01493    |   0.0 |  0.08
Output  | 2.4887e-05 | 2.4887e-05 | 2.4887e-05 |   0.0 |  0.00
Modify  | 0.061944   | 0.061944   | 0.061944   |   0.0 |  0.35
Other   |            | 0.005413   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127928 ave      127928 max      127928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127928
Ave neighs/atom = 63.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.011188451874, Press = -3.5955976725644
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8034.4777     -8034.4777     -8116.5029     -8116.5029      317.44591      317.44591      24186.128      24186.128     -710.47013     -710.47013    
     21000  -8038.4605     -8038.4605     -8118.4581     -8118.4581      309.59886      309.59886      24162.686      24162.686      622.78347      622.78347    
Loop time of 17.8252 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.847 ns/day, 4.951 hours/ns, 56.100 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.743     | 17.743     | 17.743     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015044   | 0.015044   | 0.015044   |   0.0 |  0.08
Output  | 2.3334e-05 | 2.3334e-05 | 2.3334e-05 |   0.0 |  0.00
Modify  | 0.062023   | 0.062023   | 0.062023   |   0.0 |  0.35
Other   |            | 0.005396   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127924 ave      127924 max      127924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127924
Ave neighs/atom = 63.962
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.938986463927, Press = -1.76844082520523
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8038.4605     -8038.4605     -8118.4581     -8118.4581      309.59886      309.59886      24162.686      24162.686      622.78347      622.78347    
     22000  -8035.2016     -8035.2016     -8117.7446     -8117.7446      319.44987      319.44987      24188.02       24188.02      -1020.8983     -1020.8983    
Loop time of 17.933 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.818 ns/day, 4.981 hours/ns, 55.763 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.85      | 17.85      | 17.85      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015121   | 0.015121   | 0.015121   |   0.0 |  0.08
Output  | 3.5777e-05 | 3.5777e-05 | 3.5777e-05 |   0.0 |  0.00
Modify  | 0.06195    | 0.06195    | 0.06195    |   0.0 |  0.35
Other   |            | 0.005416   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127938 ave      127938 max      127938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.8677663469, Press = -0.905613757465052
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8035.2016     -8035.2016     -8117.7446     -8117.7446      319.44987      319.44987      24188.02       24188.02      -1020.8983     -1020.8983    
     23000  -8036.3597     -8036.3597     -8117.4726     -8117.4726      313.91509      313.91509      24179.043      24179.043     -338.33938     -338.33938    
Loop time of 17.8639 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.837 ns/day, 4.962 hours/ns, 55.979 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.782     | 17.782     | 17.782     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014933   | 0.014933   | 0.014933   |   0.0 |  0.08
Output  | 2.3704e-05 | 2.3704e-05 | 2.3704e-05 |   0.0 |  0.00
Modify  | 0.06199    | 0.06199    | 0.06199    |   0.0 |  0.35
Other   |            | 0.005419   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127918 ave      127918 max      127918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127918
Ave neighs/atom = 63.959
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.696561520406, Press = -3.06846415195682
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8036.3597     -8036.3597     -8117.4726     -8117.4726      313.91509      313.91509      24179.043      24179.043     -338.33938     -338.33938    
     24000  -8035.1077     -8035.1077     -8115.7684     -8115.7684      312.16521      312.16521      24127.694      24127.694      4093.1624      4093.1624    
Loop time of 17.893 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.829 ns/day, 4.970 hours/ns, 55.888 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.811     | 17.811     | 17.811     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015032   | 0.015032   | 0.015032   |   0.0 |  0.08
Output  | 2.4336e-05 | 2.4336e-05 | 2.4336e-05 |   0.0 |  0.00
Modify  | 0.061938   | 0.061938   | 0.061938   |   0.0 |  0.35
Other   |            | 0.005445   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127934 ave      127934 max      127934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.6715709685, Press = 0.277911494717539
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8035.1077     -8035.1077     -8115.7684     -8115.7684      312.16521      312.16521      24127.694      24127.694      4093.1624      4093.1624    
     25000  -8035.8426     -8035.8426     -8114.9262     -8114.9262      306.06192      306.06192      24197.678      24197.678     -1277.9682     -1277.9682    
Loop time of 17.9359 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.817 ns/day, 4.982 hours/ns, 55.754 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.854     | 17.854     | 17.854     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014987   | 0.014987   | 0.014987   |   0.0 |  0.08
Output  | 2.3605e-05 | 2.3605e-05 | 2.3605e-05 |   0.0 |  0.00
Modify  | 0.061925   | 0.061925   | 0.061925   |   0.0 |  0.35
Other   |            | 0.005422   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127942 ave      127942 max      127942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.673950832041, Press = 2.35046549645425
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8035.8426     -8035.8426     -8114.9262     -8114.9262      306.06192      306.06192      24197.678      24197.678     -1277.9682     -1277.9682    
     26000  -8035.2334     -8035.2334     -8115.141      -8115.141       309.25045      309.25045      24191.358      24191.358     -1048.945      -1048.945     
Loop time of 17.9432 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.815 ns/day, 4.984 hours/ns, 55.731 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.861     | 17.861     | 17.861     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015016   | 0.015016   | 0.015016   |   0.0 |  0.08
Output  | 4.295e-05  | 4.295e-05  | 4.295e-05  |   0.0 |  0.00
Modify  | 0.061933   | 0.061933   | 0.061933   |   0.0 |  0.35
Other   |            | 0.005421   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127922 ave      127922 max      127922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127922
Ave neighs/atom = 63.961
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.763310634701, Press = -3.18434918341909
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8035.2334     -8035.2334     -8115.141      -8115.141       309.25045      309.25045      24191.358      24191.358     -1048.945      -1048.945     
     27000  -8035.2747     -8035.2747     -8115.8153     -8115.8153      311.7005       311.7005       24166.248      24166.248      928.73725      928.73725    
Loop time of 17.9339 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.818 ns/day, 4.982 hours/ns, 55.760 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.852     | 17.852     | 17.852     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014934   | 0.014934   | 0.014934   |   0.0 |  0.08
Output  | 2.5628e-05 | 2.5628e-05 | 2.5628e-05 |   0.0 |  0.00
Modify  | 0.061931   | 0.061931   | 0.061931   |   0.0 |  0.35
Other   |            | 0.005403   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127936 ave      127936 max      127936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127936
Ave neighs/atom = 63.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.753990653822, Press = -0.993025845965552
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8035.2747     -8035.2747     -8115.8153     -8115.8153      311.7005       311.7005       24166.248      24166.248      928.73725      928.73725    
     28000  -8036.2822     -8036.2822     -8118.9177     -8118.9177      319.80808      319.80808      24185.307      24185.307     -1012.4855     -1012.4855    
Loop time of 17.8984 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.827 ns/day, 4.972 hours/ns, 55.871 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.816     | 17.816     | 17.816     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015007   | 0.015007   | 0.015007   |   0.0 |  0.08
Output  | 2.3835e-05 | 2.3835e-05 | 2.3835e-05 |   0.0 |  0.00
Modify  | 0.061979   | 0.061979   | 0.061979   |   0.0 |  0.35
Other   |            | 0.005407   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127940 ave      127940 max      127940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127940
Ave neighs/atom = 63.97
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.788667664341, Press = -0.854419000447111
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8036.2822     -8036.2822     -8118.9177     -8118.9177      319.80808      319.80808      24185.307      24185.307     -1012.4855     -1012.4855    
     29000  -8033.2741     -8033.2741     -8116.8854     -8116.8854      323.58416      323.58416      24182.593      24182.593     -299.78711     -299.78711    
Loop time of 17.8375 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.844 ns/day, 4.955 hours/ns, 56.062 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.755     | 17.755     | 17.755     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015033   | 0.015033   | 0.015033   |   0.0 |  0.08
Output  | 4.1658e-05 | 4.1658e-05 | 4.1658e-05 |   0.0 |  0.00
Modify  | 0.061968   | 0.061968   | 0.061968   |   0.0 |  0.35
Other   |            | 0.00544    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127954 ave      127954 max      127954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127954
Ave neighs/atom = 63.977
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.686601340717, Press = -1.84502638558546
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8033.2741     -8033.2741     -8116.8854     -8116.8854      323.58416      323.58416      24182.593      24182.593     -299.78711     -299.78711    
     30000  -8036.4896     -8036.4896     -8117.0056     -8117.0056      311.60502      311.60502      24145.828      24145.828      2300.7612      2300.7612    
Loop time of 17.9709 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.808 ns/day, 4.992 hours/ns, 55.645 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.888     | 17.888     | 17.888     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015107   | 0.015107   | 0.015107   |   0.0 |  0.08
Output  | 2.5147e-05 | 2.5147e-05 | 2.5147e-05 |   0.0 |  0.00
Modify  | 0.06194    | 0.06194    | 0.06194    |   0.0 |  0.34
Other   |            | 0.005455   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127932 ave      127932 max      127932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127932
Ave neighs/atom = 63.966
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.730714465304, Press = 0.399458286303926
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8036.4896     -8036.4896     -8117.0056     -8117.0056      311.60502      311.60502      24145.828      24145.828      2300.7612      2300.7612    
     31000  -8034.6665     -8034.6665     -8115.4289     -8115.4289      312.55878      312.55878      24212.605      24212.605     -2606.6844     -2606.6844    
Loop time of 17.9216 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.821 ns/day, 4.978 hours/ns, 55.799 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.839     | 17.839     | 17.839     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015013   | 0.015013   | 0.015013   |   0.0 |  0.08
Output  | 2.3664e-05 | 2.3664e-05 | 2.3664e-05 |   0.0 |  0.00
Modify  | 0.06218    | 0.06218    | 0.06218    |   0.0 |  0.35
Other   |            | 0.005426   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127948 ave      127948 max      127948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127948
Ave neighs/atom = 63.974
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.864659583157, Press = 0.800592490187588
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8034.6665     -8034.6665     -8115.4289     -8115.4289      312.55878      312.55878      24212.605      24212.605     -2606.6844     -2606.6844    
     32000  -8033.229      -8033.229      -8115.3937     -8115.3937      317.98586      317.98586      24188.098      24188.098     -553.67755     -553.67755    
Loop time of 17.9349 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.817 ns/day, 4.982 hours/ns, 55.757 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.853     | 17.853     | 17.853     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014965   | 0.014965   | 0.014965   |   0.0 |  0.08
Output  | 2.9866e-05 | 2.9866e-05 | 2.9866e-05 |   0.0 |  0.00
Modify  | 0.061878   | 0.061878   | 0.061878   |   0.0 |  0.35
Other   |            | 0.005428   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127928 ave      127928 max      127928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127928
Ave neighs/atom = 63.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.922480045166, Press = -3.58956560787965
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8033.229      -8033.229      -8115.3937     -8115.3937      317.98586      317.98586      24188.098      24188.098     -553.67755     -553.67755    
     33000  -8037.4861     -8037.4861     -8117.9348     -8117.9348      311.34485      311.34485      24158.53       24158.53       1171.8334      1171.8334    
Loop time of 17.9222 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.821 ns/day, 4.978 hours/ns, 55.797 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.839     | 17.839     | 17.839     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014996   | 0.014996   | 0.014996   |   0.0 |  0.08
Output  | 2.4546e-05 | 2.4546e-05 | 2.4546e-05 |   0.0 |  0.00
Modify  | 0.062315   | 0.062315   | 0.062315   |   0.0 |  0.35
Other   |            | 0.005477   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127930 ave      127930 max      127930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127930
Ave neighs/atom = 63.965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.990255976212, Press = -0.865660810689791
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8037.4861     -8037.4861     -8117.9348     -8117.9348      311.34485      311.34485      24158.53       24158.53       1171.8334      1171.8334    
     34000  -8038.1708     -8038.1708     -8120.1663     -8120.1663      317.33114      317.33114      24183.549      24183.549     -1138.2844     -1138.2844    
Loop time of 17.8793 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.832 ns/day, 4.966 hours/ns, 55.931 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.797     | 17.797     | 17.797     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014924   | 0.014924   | 0.014924   |   0.0 |  0.08
Output  | 2.4085e-05 | 2.4085e-05 | 2.4085e-05 |   0.0 |  0.00
Modify  | 0.061902   | 0.061902   | 0.061902   |   0.0 |  0.35
Other   |            | 0.005491   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127952 ave      127952 max      127952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127952
Ave neighs/atom = 63.976
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.969178431694, Press = -0.425225372535751
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8038.1708     -8038.1708     -8120.1663     -8120.1663      317.33114      317.33114      24183.549      24183.549     -1138.2844     -1138.2844    
     35000  -8034.7771     -8034.7771     -8115.7635     -8115.7635      313.42556      313.42556      24176.719      24176.719      267.27218      267.27218    
Loop time of 17.8857 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.831 ns/day, 4.968 hours/ns, 55.911 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.803     | 17.803     | 17.803     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01501    | 0.01501    | 0.01501    |   0.0 |  0.08
Output  | 2.3955e-05 | 2.3955e-05 | 2.3955e-05 |   0.0 |  0.00
Modify  | 0.061968   | 0.061968   | 0.061968   |   0.0 |  0.35
Other   |            | 0.005426   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127950 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127950
Ave neighs/atom = 63.975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.871518323362, Press = -1.26289211881155
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8034.7771     -8034.7771     -8115.7635     -8115.7635      313.42556      313.42556      24176.719      24176.719      267.27218      267.27218    
     36000  -8038.9487     -8038.9487     -8117.7948     -8117.7948      305.14263      305.14263      24161.034      24161.034      995.77946      995.77946    
Loop time of 17.9365 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.817 ns/day, 4.982 hours/ns, 55.752 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.854     | 17.854     | 17.854     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015059   | 0.015059   | 0.015059   |   0.0 |  0.08
Output  | 3.75e-05   | 3.75e-05   | 3.75e-05   |   0.0 |  0.00
Modify  | 0.061929   | 0.061929   | 0.061929   |   0.0 |  0.35
Other   |            | 0.005427   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127930 ave      127930 max      127930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127930
Ave neighs/atom = 63.965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.826097773692, Press = -0.958007190612274
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8038.9487     -8038.9487     -8117.7948     -8117.7948      305.14263      305.14263      24161.034      24161.034      995.77946      995.77946    
     37000  -8036.1461     -8036.1461     -8116.0767     -8116.0767      309.33992      309.33992      24181.813      24181.813     -324.13519     -324.13519    
Loop time of 17.9135 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.823 ns/day, 4.976 hours/ns, 55.824 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.831     | 17.831     | 17.831     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015123   | 0.015123   | 0.015123   |   0.0 |  0.08
Output  | 2.4837e-05 | 2.4837e-05 | 2.4837e-05 |   0.0 |  0.00
Modify  | 0.061965   | 0.061965   | 0.061965   |   0.0 |  0.35
Other   |            | 0.00542    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127970 ave      127970 max      127970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127970
Ave neighs/atom = 63.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.868015189094, Press = -0.659253149522194
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8036.1461     -8036.1461     -8116.0767     -8116.0767      309.33992      309.33992      24181.813      24181.813     -324.13519     -324.13519    
     38000  -8036.5123     -8036.5123     -8118.136      -8118.136       315.89212      315.89212      24182.324      24182.324     -592.11149     -592.11149    
Loop time of 17.9148 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.823 ns/day, 4.976 hours/ns, 55.820 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.832     | 17.832     | 17.832     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015054   | 0.015054   | 0.015054   |   0.0 |  0.08
Output  | 2.3714e-05 | 2.3714e-05 | 2.3714e-05 |   0.0 |  0.00
Modify  | 0.06197    | 0.06197    | 0.06197    |   0.0 |  0.35
Other   |            | 0.00541    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127946 ave      127946 max      127946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127946
Ave neighs/atom = 63.973
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.901976611589, Press = -1.63469218422224
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8036.5123     -8036.5123     -8118.136      -8118.136       315.89212      315.89212      24182.324      24182.324     -592.11149     -592.11149    
     39000  -8035.3529     -8035.3529     -8116.9683     -8116.9683      315.85977      315.85977      24172.107      24172.107      498.37928      498.37928    
Loop time of 17.8656 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.836 ns/day, 4.963 hours/ns, 55.974 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.783     | 17.783     | 17.783     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014995   | 0.014995   | 0.014995   |   0.0 |  0.08
Output  | 3.9725e-05 | 3.9725e-05 | 3.9725e-05 |   0.0 |  0.00
Modify  | 0.061915   | 0.061915   | 0.061915   |   0.0 |  0.35
Other   |            | 0.005457   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127938 ave      127938 max      127938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.921677538717, Press = -1.07685117052592
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8035.3529     -8035.3529     -8116.9683     -8116.9683      315.85977      315.85977      24172.107      24172.107      498.37928      498.37928    
     40000  -8037.3101     -8037.3101     -8117.3299     -8117.3299      309.68474      309.68474      24183.993      24183.993     -697.61948     -697.61948    
Loop time of 17.9298 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.819 ns/day, 4.980 hours/ns, 55.773 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.847     | 17.847     | 17.847     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015217   | 0.015217   | 0.015217   |   0.0 |  0.08
Output  | 2.4486e-05 | 2.4486e-05 | 2.4486e-05 |   0.0 |  0.00
Modify  | 0.061902   | 0.061902   | 0.061902   |   0.0 |  0.35
Other   |            | 0.005417   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127934 ave      127934 max      127934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.87156016791, Press = 0.741024675274104
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8037.3101     -8037.3101     -8117.3299     -8117.3299      309.68474      309.68474      24183.993      24183.993     -697.61948     -697.61948    
     41000  -8035.9875     -8035.9875     -8116.5839     -8116.5839      311.91626      311.91626      24208.402      24208.402     -2327.7457     -2327.7457    
Loop time of 17.8981 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.827 ns/day, 4.972 hours/ns, 55.872 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.816     | 17.816     | 17.816     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015074   | 0.015074   | 0.015074   |   0.0 |  0.08
Output  | 2.3083e-05 | 2.3083e-05 | 2.3083e-05 |   0.0 |  0.00
Modify  | 0.06185    | 0.06185    | 0.06185    |   0.0 |  0.35
Other   |            | 0.005416   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127948 ave      127948 max      127948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127948
Ave neighs/atom = 63.974
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.921269384731, Press = -2.40171727489881
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8035.9875     -8035.9875     -8116.5839     -8116.5839      311.91626      311.91626      24208.402      24208.402     -2327.7457     -2327.7457    
     42000  -8032.0489     -8032.0489     -8115.0209     -8115.0209      321.11012      321.11012      24150.556      24150.556      2590.7874      2590.7874    
Loop time of 17.8809 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.832 ns/day, 4.967 hours/ns, 55.926 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.799     | 17.799     | 17.799     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014928   | 0.014928   | 0.014928   |   0.0 |  0.08
Output  | 2.3925e-05 | 2.3925e-05 | 2.3925e-05 |   0.0 |  0.00
Modify  | 0.061992   | 0.061992   | 0.061992   |   0.0 |  0.35
Other   |            | 0.005431   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127890 ave      127890 max      127890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127890
Ave neighs/atom = 63.945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.975767555823, Press = -1.38601026876611
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8032.0489     -8032.0489     -8115.0209     -8115.0209      321.11012      321.11012      24150.556      24150.556      2590.7874      2590.7874    
     43000  -8036.2079     -8036.2079     -8115.9396     -8115.9396      308.57016      308.57016      24178.027      24178.027      62.435167      62.435167    
Loop time of 17.8738 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.834 ns/day, 4.965 hours/ns, 55.948 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.791     | 17.791     | 17.791     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01509    | 0.01509    | 0.01509    |   0.0 |  0.08
Output  | 4.2519e-05 | 4.2519e-05 | 4.2519e-05 |   0.0 |  0.00
Modify  | 0.06206    | 0.06206    | 0.06206    |   0.0 |  0.35
Other   |            | 0.005423   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127952 ave      127952 max      127952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127952
Ave neighs/atom = 63.976
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.055577214817, Press = 0.626471406519654
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8036.2079     -8036.2079     -8115.9396     -8115.9396      308.57016      308.57016      24178.027      24178.027      62.435167      62.435167    
     44000  -8031.6027     -8031.6027     -8112.9371     -8112.9371      314.77245      314.77245      24204.648      24204.648     -1111.866      -1111.866     
Loop time of 17.8497 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.840 ns/day, 4.958 hours/ns, 56.023 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.767     | 17.767     | 17.767     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015016   | 0.015016   | 0.015016   |   0.0 |  0.08
Output  | 2.4266e-05 | 2.4266e-05 | 2.4266e-05 |   0.0 |  0.00
Modify  | 0.062084   | 0.062084   | 0.062084   |   0.0 |  0.35
Other   |            | 0.005424   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127926 ave      127926 max      127926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127926
Ave neighs/atom = 63.963
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.096180929056, Press = -1.57263234763994
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8031.6027     -8031.6027     -8112.9371     -8112.9371      314.77245      314.77245      24204.648      24204.648     -1111.866      -1111.866     
     45000  -8035.9481     -8035.9481     -8117.4027     -8117.4027      315.23748      315.23748      24171.996      24171.996      392.69904      392.69904    
Loop time of 17.885 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.831 ns/day, 4.968 hours/ns, 55.913 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.803     | 17.803     | 17.803     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015028   | 0.015028   | 0.015028   |   0.0 |  0.08
Output  | 2.3204e-05 | 2.3204e-05 | 2.3204e-05 |   0.0 |  0.00
Modify  | 0.061907   | 0.061907   | 0.061907   |   0.0 |  0.35
Other   |            | 0.005433   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127916 ave      127916 max      127916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127916
Ave neighs/atom = 63.958
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.096996766289, Press = -1.58270879169719
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8035.9481     -8035.9481     -8117.4027     -8117.4027      315.23748      315.23748      24171.996      24171.996      392.69904      392.69904    
     46000  -8036.0425     -8036.0425     -8116.6018     -8116.6018      311.77267      311.77267      24173.97       24173.97       411.09956      411.09956    
Loop time of 17.8922 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.829 ns/day, 4.970 hours/ns, 55.890 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.81      | 17.81      | 17.81      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015085   | 0.015085   | 0.015085   |   0.0 |  0.08
Output  | 4.289e-05  | 4.289e-05  | 4.289e-05  |   0.0 |  0.00
Modify  | 0.062031   | 0.062031   | 0.062031   |   0.0 |  0.35
Other   |            | 0.005425   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127956 ave      127956 max      127956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127956
Ave neighs/atom = 63.978
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.069261816502, Press = -0.413475870256359
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8036.0425     -8036.0425     -8116.6018     -8116.6018      311.77267      311.77267      24173.97       24173.97       411.09956      411.09956    
     47000  -8033.9109     -8033.9109     -8117.3953     -8117.3953      323.09322      323.09322      24192.285      24192.285     -1181.1882     -1181.1882    
Loop time of 17.8694 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.835 ns/day, 4.964 hours/ns, 55.962 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.787     | 17.787     | 17.787     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014999   | 0.014999   | 0.014999   |   0.0 |  0.08
Output  | 2.4967e-05 | 2.4967e-05 | 2.4967e-05 |   0.0 |  0.00
Modify  | 0.061866   | 0.061866   | 0.061866   |   0.0 |  0.35
Other   |            | 0.005425   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127936 ave      127936 max      127936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127936
Ave neighs/atom = 63.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.998604514895, Press = -0.48241177884544
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8033.9109     -8033.9109     -8117.3953     -8117.3953      323.09322      323.09322      24192.285      24192.285     -1181.1882     -1181.1882    
     48000  -8036.3283     -8036.3283     -8117.3268     -8117.3268      313.47239      313.47239      24173.557      24173.557      198.20555      198.20555    
Loop time of 17.9331 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.818 ns/day, 4.981 hours/ns, 55.763 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.851     | 17.851     | 17.851     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015056   | 0.015056   | 0.015056   |   0.0 |  0.08
Output  | 2.688e-05  | 2.688e-05  | 2.688e-05  |   0.0 |  0.00
Modify  | 0.061887   | 0.061887   | 0.061887   |   0.0 |  0.35
Other   |            | 0.005441   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127942 ave      127942 max      127942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.016506945869, Press = -1.49176839213323
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8036.3283     -8036.3283     -8117.3268     -8117.3268      313.47239      313.47239      24173.557      24173.557      198.20555      198.20555    
     49000  -8031.6702     -8031.6702     -8113.7494     -8113.7494      317.65511      317.65511      24181.864      24181.864      285.2205       285.2205     
Loop time of 17.922 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.821 ns/day, 4.978 hours/ns, 55.797 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.84      | 17.84      | 17.84      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015009   | 0.015009   | 0.015009   |   0.0 |  0.08
Output  | 3.6298e-05 | 3.6298e-05 | 3.6298e-05 |   0.0 |  0.00
Modify  | 0.061913   | 0.061913   | 0.061913   |   0.0 |  0.35
Other   |            | 0.005422   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127950 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127950
Ave neighs/atom = 63.975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.033881753683, Press = -0.665858718833876
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8031.6702     -8031.6702     -8113.7494     -8113.7494      317.65511      317.65511      24181.864      24181.864      285.2205       285.2205     
     50000  -8036.0051     -8036.0051     -8115.6433     -8115.6433      308.20816      308.20816      24175.271      24175.271      589.82662      589.82662    
Loop time of 17.9289 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.819 ns/day, 4.980 hours/ns, 55.776 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.846     | 17.846     | 17.846     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014995   | 0.014995   | 0.014995   |   0.0 |  0.08
Output  | 2.4195e-05 | 2.4195e-05 | 2.4195e-05 |   0.0 |  0.00
Modify  | 0.061943   | 0.061943   | 0.061943   |   0.0 |  0.35
Other   |            | 0.00541    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127938 ave      127938 max      127938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.082993894429, Press = -0.881574037363653
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8036.0051     -8036.0051     -8115.6433     -8115.6433      308.20816      308.20816      24175.271      24175.271      589.82662      589.82662    
     51000  -8031.8124     -8031.8124     -8114.5559     -8114.5559      320.22611      320.22611      24192.478      24192.478     -599.72302     -599.72302    
Loop time of 17.9512 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.813 ns/day, 4.986 hours/ns, 55.706 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.869     | 17.869     | 17.869     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014994   | 0.014994   | 0.014994   |   0.0 |  0.08
Output  | 2.3013e-05 | 2.3013e-05 | 2.3013e-05 |   0.0 |  0.00
Modify  | 0.061943   | 0.061943   | 0.061943   |   0.0 |  0.35
Other   |            | 0.005404   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127952 ave      127952 max      127952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127952
Ave neighs/atom = 63.976
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.14593779598, Press = -1.04988001232095
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8031.8124     -8031.8124     -8114.5559     -8114.5559      320.22611      320.22611      24192.478      24192.478     -599.72302     -599.72302    
     52000  -8033.8913     -8033.8913     -8114.7076     -8114.7076      312.76762      312.76762      24188.272      24188.272     -488.97592     -488.97592    
Loop time of 17.896 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.828 ns/day, 4.971 hours/ns, 55.878 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.813     | 17.813     | 17.813     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015009   | 0.015009   | 0.015009   |   0.0 |  0.08
Output  | 4.9864e-05 | 4.9864e-05 | 4.9864e-05 |   0.0 |  0.00
Modify  | 0.062287   | 0.062287   | 0.062287   |   0.0 |  0.35
Other   |            | 0.005404   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127922 ave      127922 max      127922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127922
Ave neighs/atom = 63.961
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.158094931457, Press = -1.64623815121976
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8033.8913     -8033.8913     -8114.7076     -8114.7076      312.76762      312.76762      24188.272      24188.272     -488.97592     -488.97592    
     53000  -8033.3118     -8033.3118     -8114.5408     -8114.5408      314.36448      314.36448      24157.954      24157.954      2113.3207      2113.3207    
Loop time of 17.8392 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.843 ns/day, 4.955 hours/ns, 56.056 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.757     | 17.757     | 17.757     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015114   | 0.015114   | 0.015114   |   0.0 |  0.08
Output  | 3.8502e-05 | 3.8502e-05 | 3.8502e-05 |   0.0 |  0.00
Modify  | 0.062011   | 0.062011   | 0.062011   |   0.0 |  0.35
Other   |            | 0.00544    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127896 ave      127896 max      127896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127896
Ave neighs/atom = 63.948
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.191630068503, Press = -1.42083309787625
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8033.3118     -8033.3118     -8114.5408     -8114.5408      314.36448      314.36448      24157.954      24157.954      2113.3207      2113.3207    
     54000  -8035.4321     -8035.4321     -8116.2168     -8116.2168      312.64519      312.64519      24181.11       24181.11      -150.37539     -150.37539    
Loop time of 17.8959 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.828 ns/day, 4.971 hours/ns, 55.879 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.814     | 17.814     | 17.814     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014988   | 0.014988   | 0.014988   |   0.0 |  0.08
Output  | 2.4085e-05 | 2.4085e-05 | 2.4085e-05 |   0.0 |  0.00
Modify  | 0.061895   | 0.061895   | 0.061895   |   0.0 |  0.35
Other   |            | 0.005409   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127930 ave      127930 max      127930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127930
Ave neighs/atom = 63.965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.191369915073, Press = 0.385961321699254
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8035.4321     -8035.4321     -8116.2168     -8116.2168      312.64519      312.64519      24181.11       24181.11      -150.37539     -150.37539    
     55000  -8034.0351     -8034.0351     -8115.8821     -8115.8821      316.75632      316.75632      24228.731      24228.731     -3747.4428     -3747.4428    
Loop time of 17.9672 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.809 ns/day, 4.991 hours/ns, 55.657 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.885     | 17.885     | 17.885     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015056   | 0.015056   | 0.015056   |   0.0 |  0.08
Output  | 2.3965e-05 | 2.3965e-05 | 2.3965e-05 |   0.0 |  0.00
Modify  | 0.062112   | 0.062112   | 0.062112   |   0.0 |  0.35
Other   |            | 0.005436   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127932 ave      127932 max      127932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127932
Ave neighs/atom = 63.966
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.188441303385, Press = -2.22400824062741
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8034.0351     -8034.0351     -8115.8821     -8115.8821      316.75632      316.75632      24228.731      24228.731     -3747.4428     -3747.4428    
     56000  -8039.8738     -8039.8738     -8120.0667     -8120.0667      310.35482      310.35482      24145.942      24145.942      1904.9011      1904.9011    
Loop time of 17.9501 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.813 ns/day, 4.986 hours/ns, 55.710 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.867     | 17.867     | 17.867     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015053   | 0.015053   | 0.015053   |   0.0 |  0.08
Output  | 3.6919e-05 | 3.6919e-05 | 3.6919e-05 |   0.0 |  0.00
Modify  | 0.062448   | 0.062448   | 0.062448   |   0.0 |  0.35
Other   |            | 0.005438   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127922 ave      127922 max      127922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127922
Ave neighs/atom = 63.961
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.152102419966, Press = -1.24751239393125
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8039.8738     -8039.8738     -8120.0667     -8120.0667      310.35482      310.35482      24145.942      24145.942      1904.9011      1904.9011    
     57000  -8033.9168     -8033.9168     -8113.5926     -8113.5926      308.35335      308.35335      24172.292      24172.292      1241.0451      1241.0451    
Loop time of 17.8782 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.833 ns/day, 4.966 hours/ns, 55.934 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.796     | 17.796     | 17.796     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015019   | 0.015019   | 0.015019   |   0.0 |  0.08
Output  | 2.4666e-05 | 2.4666e-05 | 2.4666e-05 |   0.0 |  0.00
Modify  | 0.06219    | 0.06219    | 0.06219    |   0.0 |  0.35
Other   |            | 0.00544    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127954 ave      127954 max      127954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127954
Ave neighs/atom = 63.977
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.115772484941, Press = -0.477830468277715
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -8033.9168     -8033.9168     -8113.5926     -8113.5926      308.35335      308.35335      24172.292      24172.292      1241.0451      1241.0451    
     58000  -8037.7017     -8037.7017     -8117.1682     -8117.1682      307.54325      307.54325      24199.297      24199.297     -1786.9565     -1786.9565    
Loop time of 17.9004 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.827 ns/day, 4.972 hours/ns, 55.865 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.818     | 17.818     | 17.818     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014995   | 0.014995   | 0.014995   |   0.0 |  0.08
Output  | 2.4115e-05 | 2.4115e-05 | 2.4115e-05 |   0.0 |  0.00
Modify  | 0.061947   | 0.061947   | 0.061947   |   0.0 |  0.35
Other   |            | 0.005389   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127946 ave      127946 max      127946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127946
Ave neighs/atom = 63.973
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.078809725077, Press = -0.875659656700583
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -8037.7017     -8037.7017     -8117.1682     -8117.1682      307.54325      307.54325      24199.297      24199.297     -1786.9565     -1786.9565    
     59000  -8033.047      -8033.047      -8116.4435     -8116.4435      322.75316      322.75316      24172.393      24172.393      537.472        537.472      
Loop time of 17.874 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.834 ns/day, 4.965 hours/ns, 55.947 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.792     | 17.792     | 17.792     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014986   | 0.014986   | 0.014986   |   0.0 |  0.08
Output  | 3.6678e-05 | 3.6678e-05 | 3.6678e-05 |   0.0 |  0.00
Modify  | 0.061988   | 0.061988   | 0.061988   |   0.0 |  0.35
Other   |            | 0.005431   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127918 ave      127918 max      127918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127918
Ave neighs/atom = 63.959
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.074921449926, Press = -1.73519569027639
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8033.047      -8033.047      -8116.4435     -8116.4435      322.75316      322.75316      24172.393      24172.393      537.472        537.472      
     60000  -8034.2373     -8034.2373     -8116.2221     -8116.2221      317.28958      317.28958      24148.562      24148.562      2382.997       2382.997     
Loop time of 17.8845 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.831 ns/day, 4.968 hours/ns, 55.914 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.802     | 17.802     | 17.802     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015026   | 0.015026   | 0.015026   |   0.0 |  0.08
Output  | 2.3655e-05 | 2.3655e-05 | 2.3655e-05 |   0.0 |  0.00
Modify  | 0.062103   | 0.062103   | 0.062103   |   0.0 |  0.35
Other   |            | 0.005439   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127942 ave      127942 max      127942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.089308413762, Press = 0.260525377443141
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -8034.2373     -8034.2373     -8116.2221     -8116.2221      317.28958      317.28958      24148.562      24148.562      2382.997       2382.997     
     61000  -8035.6089     -8035.6089     -8116.0261     -8116.0261      311.22271      311.22271      24224.963      24224.963     -3735.6538     -3735.6538    
Loop time of 17.9321 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.818 ns/day, 4.981 hours/ns, 55.766 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.849     | 17.849     | 17.849     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015008   | 0.015008   | 0.015008   |   0.0 |  0.08
Output  | 2.3474e-05 | 2.3474e-05 | 2.3474e-05 |   0.0 |  0.00
Modify  | 0.062289   | 0.062289   | 0.062289   |   0.0 |  0.35
Other   |            | 0.005413   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127934 ave      127934 max      127934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.068311894593, Press = -0.3843806421867
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -8035.6089     -8035.6089     -8116.0261     -8116.0261      311.22271      311.22271      24224.963      24224.963     -3735.6538     -3735.6538    
     62000  -8038.3978     -8038.3978     -8116.9584     -8116.9584      304.03768      304.03768      24182.537      24182.537     -464.90903     -464.90903    
Loop time of 17.975 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.807 ns/day, 4.993 hours/ns, 55.633 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.893     | 17.893     | 17.893     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014992   | 0.014992   | 0.014992   |   0.0 |  0.08
Output  | 2.3755e-05 | 2.3755e-05 | 2.3755e-05 |   0.0 |  0.00
Modify  | 0.06194    | 0.06194    | 0.06194    |   0.0 |  0.34
Other   |            | 0.005412   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127922 ave      127922 max      127922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127922
Ave neighs/atom = 63.961
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.060393556362, Press = -2.12753237533409
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -8038.3978     -8038.3978     -8116.9584     -8116.9584      304.03768      304.03768      24182.537      24182.537     -464.90903     -464.90903    
     63000  -8035.5073     -8035.5073     -8116.4863     -8116.4863      313.39697      313.39697      24140.135      24140.135      2886.9831      2886.9831    
Loop time of 17.8759 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.833 ns/day, 4.966 hours/ns, 55.941 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.793     | 17.793     | 17.793     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014978   | 0.014978   | 0.014978   |   0.0 |  0.08
Output  | 4.1608e-05 | 4.1608e-05 | 4.1608e-05 |   0.0 |  0.00
Modify  | 0.062002   | 0.062002   | 0.062002   |   0.0 |  0.35
Other   |            | 0.005432   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127942 ave      127942 max      127942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.011156502467, Press = -0.29927205843715
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -8035.5073     -8035.5073     -8116.4863     -8116.4863      313.39697      313.39697      24140.135      24140.135      2886.9831      2886.9831    
     64000  -8037.6585     -8037.6585     -8118.336      -8118.336       312.22993      312.22993      24197.847      24197.847     -1929.4933     -1929.4933    
Loop time of 17.865 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.836 ns/day, 4.962 hours/ns, 55.976 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.783     | 17.783     | 17.783     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014965   | 0.014965   | 0.014965   |   0.0 |  0.08
Output  | 2.5368e-05 | 2.5368e-05 | 2.5368e-05 |   0.0 |  0.00
Modify  | 0.061835   | 0.061835   | 0.061835   |   0.0 |  0.35
Other   |            | 0.005411   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127918 ave      127918 max      127918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127918
Ave neighs/atom = 63.959
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.00422528171, Press = -0.316360075157833
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -8037.6585     -8037.6585     -8118.336      -8118.336       312.22993      312.22993      24197.847      24197.847     -1929.4933     -1929.4933    
     65000  -8035.4711     -8035.4711     -8115.5023     -8115.5023      309.72898      309.72898      24188.849      24188.849     -807.0707      -807.0707     
Loop time of 17.911 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.824 ns/day, 4.975 hours/ns, 55.832 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.829     | 17.829     | 17.829     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015021   | 0.015021   | 0.015021   |   0.0 |  0.08
Output  | 2.3193e-05 | 2.3193e-05 | 2.3193e-05 |   0.0 |  0.00
Modify  | 0.061898   | 0.061898   | 0.061898   |   0.0 |  0.35
Other   |            | 0.005426   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127950 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127950
Ave neighs/atom = 63.975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.99606484734, Press = -1.65060589199774
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -8035.4711     -8035.4711     -8115.5023     -8115.5023      309.72898      309.72898      24188.849      24188.849     -807.0707      -807.0707     
     66000  -8033.5695     -8033.5695     -8116.6881     -8116.6881      321.67747      321.67747      24154.657      24154.657      1899.6763      1899.6763    
Loop time of 17.9233 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.821 ns/day, 4.979 hours/ns, 55.793 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.841     | 17.841     | 17.841     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014972   | 0.014972   | 0.014972   |   0.0 |  0.08
Output  | 3.718e-05  | 3.718e-05  | 3.718e-05  |   0.0 |  0.00
Modify  | 0.061928   | 0.061928   | 0.061928   |   0.0 |  0.35
Other   |            | 0.00543    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127936 ave      127936 max      127936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127936
Ave neighs/atom = 63.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.997651885891, Press = -0.658472128732734
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -8033.5695     -8033.5695     -8116.6881     -8116.6881      321.67747      321.67747      24154.657      24154.657      1899.6763      1899.6763    
     67000  -8032.1489     -8032.1489     -8113.4245     -8113.4245      314.54473      314.54473      24196.824      24196.824     -690.06036     -690.06036    
Loop time of 18.0242 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.794 ns/day, 5.007 hours/ns, 55.481 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.942     | 17.942     | 17.942     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015049   | 0.015049   | 0.015049   |   0.0 |  0.08
Output  | 2.4305e-05 | 2.4305e-05 | 2.4305e-05 |   0.0 |  0.00
Modify  | 0.061894   | 0.061894   | 0.061894   |   0.0 |  0.34
Other   |            | 0.005424   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127944 ave      127944 max      127944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0