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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 2.8809778466820717*${_u_distance}
variable latticeconst_converted equal 2.8809778466820717*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.88097784668207
Lattice spacing in x,y,z = 2.8809778 2.8809778 2.8809778
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.809778 28.809778 28.809778)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.809778 28.809778 28.809778)
  create_atoms CPU = 0.004 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_LeeShimPark_2001_FeCr__MO_150993986463_000
pair_coeff * * Cr
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 51.9961

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

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.0848   -8119.0848        -8200        -8200       313.15       313.15    23912.212    23912.212    3614.3324    3614.3324 
    1000   -8031.4482   -8031.4482   -8116.2855   -8116.2855    328.32891    328.32891    24096.422    24096.422    294.28761    294.28761 
Loop time of 104.625 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.063 hours/ns, 9.558 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.1      | 104.1      | 104.1      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10253    | 0.10253    | 0.10253    |   0.0 |  0.10
Output  | 0.00024153 | 0.00024153 | 0.00024153 |   0.0 |  0.00
Modify  | 0.36546    | 0.36546    | 0.36546    |   0.0 |  0.35
Other   |            | 0.06172    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
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   -8031.4482   -8031.4482   -8116.2855   -8116.2855    328.32891    328.32891    24096.422    24096.422    294.28761    294.28761 
    2000   -8033.3256   -8033.3256   -8111.5068   -8111.5068    302.56915    302.56915     24120.17     24120.17    -1646.173    -1646.173 
Loop time of 108.262 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.798 ns/day, 30.073 hours/ns, 9.237 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.73     | 107.73     | 107.73     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10178    | 0.10178    | 0.10178    |   0.0 |  0.09
Output  | 0.00019698 | 0.00019698 | 0.00019698 |   0.0 |  0.00
Modify  | 0.36495    | 0.36495    | 0.36495    |   0.0 |  0.34
Other   |            | 0.06117    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127964.0 ave      127964 max      127964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127964
Ave neighs/atom = 63.982000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
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   -8033.3256   -8033.3256   -8111.5068   -8111.5068    302.56915    302.56915     24120.17     24120.17    -1646.173    -1646.173 
    3000   -8033.4728   -8033.4728   -8111.9074   -8111.9074    303.55003    303.55003    24104.445    24104.445   -354.90808   -354.90808 
Loop time of 112.191 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.770 ns/day, 31.164 hours/ns, 8.913 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.64     | 111.64     | 111.64     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10516    | 0.10516    | 0.10516    |   0.0 |  0.09
Output  | 0.0001924  | 0.0001924  | 0.0001924  |   0.0 |  0.00
Modify  | 0.38519    | 0.38519    | 0.38519    |   0.0 |  0.34
Other   |            | 0.06379    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127954.0 ave      127954 max      127954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127954
Ave neighs/atom = 63.977000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
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   -8033.4728   -8033.4728   -8111.9074   -8111.9074    303.55003    303.55003    24104.445    24104.445   -354.90808   -354.90808 
    4000    -8032.231    -8032.231   -8115.0644   -8115.0644    320.57394    320.57394    24071.012    24071.012    1979.3964    1979.3964 
Loop time of 115.393 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.749 ns/day, 32.054 hours/ns, 8.666 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.82     | 114.82     | 114.82     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10682    | 0.10682    | 0.10682    |   0.0 |  0.09
Output  | 0.0002373  | 0.0002373  | 0.0002373  |   0.0 |  0.00
Modify  | 0.39749    | 0.39749    | 0.39749    |   0.0 |  0.34
Other   |            | 0.06383    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127960.0 ave      127960 max      127960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127960
Ave neighs/atom = 63.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
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    -8032.231    -8032.231   -8115.0644   -8115.0644    320.57394    320.57394    24071.012    24071.012    1979.3964    1979.3964 
    5000   -8033.9861   -8033.9861   -8114.1873   -8114.1873    310.38709    310.38709    24080.433    24080.433    1502.5626    1502.5626 
Loop time of 115.004 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.751 ns/day, 31.945 hours/ns, 8.695 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.43     | 114.43     | 114.43     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10671    | 0.10671    | 0.10671    |   0.0 |  0.09
Output  | 0.00021258 | 0.00021258 | 0.00021258 |   0.0 |  0.00
Modify  | 0.40136    | 0.40136    | 0.40136    |   0.0 |  0.35
Other   |            | 0.06433    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4118.00 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127930.0 ave      127930 max      127930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127930
Ave neighs/atom = 63.965000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 310.505877234437, Press = 2108.16126467697
next a
jump SELF top
variable a loop 2000
run 1000
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   -8033.9861   -8033.9861   -8114.1873   -8114.1873    310.38709    310.38709    24080.433    24080.433    1502.5626    1502.5626 
    6000   -8031.9152   -8031.9152   -8113.6606   -8113.6606    316.36348    316.36348    24138.155    24138.155   -2982.8728   -2982.8728 
Loop time of 113.709 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.586 hours/ns, 8.794 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.13     | 113.13     | 113.13     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1054     | 0.1054     | 0.1054     |   0.0 |  0.09
Output  | 0.00019532 | 0.00019532 | 0.00019532 |   0.0 |  0.00
Modify  | 0.41287    | 0.41287    | 0.41287    |   0.0 |  0.36
Other   |            | 0.06395    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127948.0 ave      127948 max      127948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127948
Ave neighs/atom = 63.974000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.328116538341, Press = 91.2940866791823
next a
jump SELF top
variable a loop 2000
run 1000
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   -8031.9152   -8031.9152   -8113.6606   -8113.6606    316.36348    316.36348    24138.155    24138.155   -2982.8728   -2982.8728 
    7000   -8036.7364   -8036.7364   -8116.0932   -8116.0932    307.11914    307.11914    24100.523    24100.523   -562.04398   -562.04398 
Loop time of 112.059 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.49     | 111.49     | 111.49     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10454    | 0.10454    | 0.10454    |   0.0 |  0.09
Output  | 0.00015559 | 0.00015559 | 0.00015559 |   0.0 |  0.00
Modify  | 0.40319    | 0.40319    | 0.40319    |   0.0 |  0.36
Other   |            | 0.06324    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4118.00 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127914.0 ave      127914 max      127914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127914
Ave neighs/atom = 63.957000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.819936744632, Press = 9.26497414712279
next a
jump SELF top
variable a loop 2000
run 1000
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.7364   -8036.7364   -8116.0932   -8116.0932    307.11914    307.11914    24100.523    24100.523   -562.04398   -562.04398 
    8000    -8031.483    -8031.483   -8112.8135   -8112.8135    314.75728    314.75728    24073.359    24073.359    1954.9676    1954.9676 
Loop time of 114.929 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.752 ns/day, 31.925 hours/ns, 8.701 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.34     | 114.34     | 114.34     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10635    | 0.10635    | 0.10635    |   0.0 |  0.09
Output  | 0.00023582 | 0.00023582 | 0.00023582 |   0.0 |  0.00
Modify  | 0.41745    | 0.41745    | 0.41745    |   0.0 |  0.36
Other   |            | 0.06344    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127968.0 ave      127968 max      127968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127968
Ave neighs/atom = 63.984000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.748302946048, Press = 27.37735809229
next a
jump SELF top
variable a loop 2000
run 1000
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    -8031.483    -8031.483   -8112.8135   -8112.8135    314.75728    314.75728    24073.359    24073.359    1954.9676    1954.9676 
    9000    -8035.299    -8035.299   -8116.2316   -8116.2316    313.21782    313.21782    24095.235    24095.235   -77.447304   -77.447304 
Loop time of 113.137 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.56     | 112.56     | 112.56     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10579    | 0.10579    | 0.10579    |   0.0 |  0.09
Output  | 0.0002557  | 0.0002557  | 0.0002557  |   0.0 |  0.00
Modify  | 0.41137    | 0.41137    | 0.41137    |   0.0 |  0.36
Other   |            | 0.06266    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127952.0 ave      127952 max      127952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127952
Ave neighs/atom = 63.976000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.639019668948, Press = 34.4665124945172
next a
jump SELF top
variable a loop 2000
run 1000
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    -8035.299    -8035.299   -8116.2316   -8116.2316    313.21782    313.21782    24095.235    24095.235   -77.447304   -77.447304 
   10000   -8032.9393   -8032.9393   -8114.0123   -8114.0123     313.7608     313.7608    24141.973    24141.973   -3210.9774   -3210.9774 
Loop time of 113.514 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.532 hours/ns, 8.809 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.93     | 112.93     | 112.93     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10572    | 0.10572    | 0.10572    |   0.0 |  0.09
Output  | 0.00019505 | 0.00019505 | 0.00019505 |   0.0 |  0.00
Modify  | 0.41155    | 0.41155    | 0.41155    |   0.0 |  0.36
Other   |            | 0.06339    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127960.0 ave      127960 max      127960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127960
Ave neighs/atom = 63.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.40749329183, Press = 13.6423712861536
next a
jump SELF top
variable a loop 2000
run 1000
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   -8032.9393   -8032.9393   -8114.0123   -8114.0123     313.7608     313.7608    24141.973    24141.973   -3210.9774   -3210.9774 
   11000   -8030.5081   -8030.5081   -8112.6296   -8112.6296    317.81853    317.81853    24099.059    24099.059    134.34875    134.34875 
Loop time of 114.205 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.724 hours/ns, 8.756 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.62     | 113.62     | 113.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10657    | 0.10657    | 0.10657    |   0.0 |  0.09
Output  | 0.00023456 | 0.00023456 | 0.00023456 |   0.0 |  0.00
Modify  | 0.41602    | 0.41602    | 0.41602    |   0.0 |  0.36
Other   |            | 0.06305    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127946.0 ave      127946 max      127946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127946
Ave neighs/atom = 63.973000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.562996600313, Press = -3.61400749776307
next a
jump SELF top
variable a loop 2000
run 1000
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   -8030.5081   -8030.5081   -8112.6296   -8112.6296    317.81853    317.81853    24099.059    24099.059    134.34875    134.34875 
   12000   -8033.0004   -8033.0004   -8111.6273   -8111.6273    304.29427    304.29427    24067.304    24067.304    2547.4102    2547.4102 
Loop time of 114.482 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.801 hours/ns, 8.735 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.9      | 113.9      | 113.9      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10551    | 0.10551    | 0.10551    |   0.0 |  0.09
Output  | 0.00015457 | 0.00015457 | 0.00015457 |   0.0 |  0.00
Modify  | 0.4119     | 0.4119     | 0.4119     |   0.0 |  0.36
Other   |            | 0.06377    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127962.0 ave      127962 max      127962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127962
Ave neighs/atom = 63.981000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.299198516676, Press = 13.728344696469
next a
jump SELF top
variable a loop 2000
run 1000
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   -8033.0004   -8033.0004   -8111.6273   -8111.6273    304.29427    304.29427    24067.304    24067.304    2547.4102    2547.4102 
   13000   -8031.8601   -8031.8601   -8111.3962   -8111.3962    307.81277    307.81277    24100.378    24100.378    66.716748    66.716748 
Loop time of 110.81 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.780 ns/day, 30.780 hours/ns, 9.024 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.25     | 110.25     | 110.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10377    | 0.10377    | 0.10377    |   0.0 |  0.09
Output  | 0.0001539  | 0.0001539  | 0.0001539  |   0.0 |  0.00
Modify  | 0.39818    | 0.39818    | 0.39818    |   0.0 |  0.36
Other   |            | 0.06246    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4118.00 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127948.0 ave      127948 max      127948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127948
Ave neighs/atom = 63.974000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.50894699716, Press = 16.1453963114664
next a
jump SELF top
variable a loop 2000
run 1000
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   -8031.8601   -8031.8601   -8111.3962   -8111.3962    307.81277    307.81277    24100.378    24100.378    66.716748    66.716748 
   14000   -8033.4001   -8033.4001   -8113.4602   -8113.4602    309.84094    309.84094    24117.175    24117.175    -1409.145    -1409.145 
Loop time of 110.361 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.783 ns/day, 30.656 hours/ns, 9.061 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.8      | 109.8      | 109.8      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10375    | 0.10375    | 0.10375    |   0.0 |  0.09
Output  | 0.00019752 | 0.00019752 | 0.00019752 |   0.0 |  0.00
Modify  | 0.39386    | 0.39386    | 0.39386    |   0.0 |  0.36
Other   |            | 0.06226    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127922.0 ave      127922 max      127922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127922
Ave neighs/atom = 63.961000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.649014260331, Press = 7.04057221739001
next a
jump SELF top
variable a loop 2000
run 1000
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   -8033.4001   -8033.4001   -8113.4602   -8113.4602    309.84094    309.84094    24117.175    24117.175    -1409.145    -1409.145 
   15000   -8031.5912   -8031.5912    -8112.251    -8112.251    312.16185    312.16185    24087.267    24087.267    1100.1587    1100.1587 
Loop time of 110.414 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.783 ns/day, 30.671 hours/ns, 9.057 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.85     | 109.85     | 109.85     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10475    | 0.10475    | 0.10475    |   0.0 |  0.09
Output  | 0.00015269 | 0.00015269 | 0.00015269 |   0.0 |  0.00
Modify  | 0.39646    | 0.39646    | 0.39646    |   0.0 |  0.36
Other   |            | 0.06245    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127930.0 ave      127930 max      127930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127930
Ave neighs/atom = 63.965000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.602095413784, Press = 4.88470744074263
next a
jump SELF top
variable a loop 2000
run 1000
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   -8031.5912   -8031.5912    -8112.251    -8112.251    312.16185    312.16185    24087.267    24087.267    1100.1587    1100.1587 
   16000   -8035.8265   -8035.8265   -8115.8709   -8115.8709    309.78016    309.78016     24029.63     24029.63    5022.6405    5022.6405 
Loop time of 115.593 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.747 ns/day, 32.109 hours/ns, 8.651 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115        | 115        | 115        |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10886    | 0.10886    | 0.10886    |   0.0 |  0.09
Output  | 0.00019865 | 0.00019865 | 0.00019865 |   0.0 |  0.00
Modify  | 0.42084    | 0.42084    | 0.42084    |   0.0 |  0.36
Other   |            | 0.06448    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127964.0 ave      127964 max      127964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127964
Ave neighs/atom = 63.982000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.544546825932, Press = 15.7774162373622
next a
jump SELF top
variable a loop 2000
run 1000
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   -8035.8265   -8035.8265   -8115.8709   -8115.8709    309.78016    309.78016     24029.63     24029.63    5022.6405    5022.6405 
   17000   -8033.5414   -8033.5414   -8114.9964   -8114.9964     315.2393     315.2393    24124.108    24124.108   -2034.7306   -2034.7306 
Loop time of 111.777 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.773 ns/day, 31.049 hours/ns, 8.946 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.21     | 111.21     | 111.21     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10445    | 0.10445    | 0.10445    |   0.0 |  0.09
Output  | 0.00015241 | 0.00015241 | 0.00015241 |   0.0 |  0.00
Modify  | 0.39914    | 0.39914    | 0.39914    |   0.0 |  0.36
Other   |            | 0.06293    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127968.0 ave      127968 max      127968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127968
Ave neighs/atom = 63.984000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.340349768781, Press = 13.0004051848193
next a
jump SELF top
variable a loop 2000
run 1000
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   -8033.5414   -8033.5414   -8114.9964   -8114.9964     315.2393     315.2393    24124.108    24124.108   -2034.7306   -2034.7306 
   18000   -8032.6128   -8032.6128   -8112.8953   -8112.8953    310.70164    310.70164    24122.994    24122.994   -1753.5896   -1753.5896 
Loop time of 113.454 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.515 hours/ns, 8.814 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.88     | 112.88     | 112.88     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10603    | 0.10603    | 0.10603    |   0.0 |  0.09
Output  | 0.00015377 | 0.00015377 | 0.00015377 |   0.0 |  0.00
Modify  | 0.40867    | 0.40867    | 0.40867    |   0.0 |  0.36
Other   |            | 0.06347    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127956.0 ave      127956 max      127956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127956
Ave neighs/atom = 63.978000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.456177813605, Press = 3.40215534485741
next a
jump SELF top
variable a loop 2000
run 1000
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   -8032.6128   -8032.6128   -8112.8953   -8112.8953    310.70164    310.70164    24122.994    24122.994   -1753.5896   -1753.5896 
   19000   -8035.6685   -8035.6685   -8115.5646   -8115.5646    309.20595    309.20595    24076.998    24076.998    1458.1779    1458.1779 
Loop time of 109.532 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.789 ns/day, 30.426 hours/ns, 9.130 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.97     | 108.97     | 108.97     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1041     | 0.1041     | 0.1041     |   0.0 |  0.10
Output  | 0.00018475 | 0.00018475 | 0.00018475 |   0.0 |  0.00
Modify  | 0.39208    | 0.39208    | 0.39208    |   0.0 |  0.36
Other   |            | 0.06205    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127940.0 ave      127940 max      127940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127940
Ave neighs/atom = 63.970000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.307456543268, Press = 3.9028116097792
next a
jump SELF top
variable a loop 2000
run 1000
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.6685   -8035.6685   -8115.5646   -8115.5646    309.20595    309.20595    24076.998    24076.998    1458.1779    1458.1779 
   20000   -8031.2926   -8031.2926   -8112.9579   -8112.9579    316.05304    316.05304    24084.777    24084.777    1331.0728    1331.0728 
Loop time of 114.126 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.702 hours/ns, 8.762 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.54     | 113.54     | 113.54     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10645    | 0.10645    | 0.10645    |   0.0 |  0.09
Output  | 0.00015255 | 0.00015255 | 0.00015255 |   0.0 |  0.00
Modify  | 0.4137     | 0.4137     | 0.4137     |   0.0 |  0.36
Other   |            | 0.06368    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127960.0 ave      127960 max      127960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127960
Ave neighs/atom = 63.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.330448302622, Press = 8.67168008291633
next a
jump SELF top
variable a loop 2000
run 1000
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   -8031.2926   -8031.2926   -8112.9579   -8112.9579    316.05304    316.05304    24084.777    24084.777    1331.0728    1331.0728 
   21000   -8030.7532   -8030.7532   -8113.2826   -8113.2826    319.39756    319.39756    24142.994    24142.994   -3287.2249   -3287.2249 
Loop time of 113.523 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.534 hours/ns, 8.809 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.93     | 112.93     | 112.93     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10682    | 0.10682    | 0.10682    |   0.0 |  0.09
Output  | 0.00019833 | 0.00019833 | 0.00019833 |   0.0 |  0.00
Modify  | 0.41694    | 0.41694    | 0.41694    |   0.0 |  0.37
Other   |            | 0.06377    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127924.0 ave      127924 max      127924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127924
Ave neighs/atom = 63.962000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.264801241275, Press = 7.899695388101
next a
jump SELF top
variable a loop 2000
run 1000
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   -8030.7532   -8030.7532   -8113.2826   -8113.2826    319.39756    319.39756    24142.994    24142.994   -3287.2249   -3287.2249 
   22000   -8031.9959   -8031.9959   -8111.4902   -8111.4902     307.6512     307.6512    24128.381    24128.381   -1962.3615   -1962.3615 
Loop time of 112.803 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.23     | 112.23     | 112.23     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10542    | 0.10542    | 0.10542    |   0.0 |  0.09
Output  | 0.00015397 | 0.00015397 | 0.00015397 |   0.0 |  0.00
Modify  | 0.40637    | 0.40637    | 0.40637    |   0.0 |  0.36
Other   |            | 0.06387    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127944.0 ave      127944 max      127944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127944
Ave neighs/atom = 63.972000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.317071479951, Press = -0.482812603713935
next a
jump SELF top
variable a loop 2000
run 1000
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   -8031.9959   -8031.9959   -8111.4902   -8111.4902     307.6512     307.6512    24128.381    24128.381   -1962.3615   -1962.3615 
   23000   -8033.1838   -8033.1838   -8114.0425   -8114.0425    312.93154    312.93154    24076.779    24076.779    1701.0252    1701.0252 
Loop time of 106.9 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.694 hours/ns, 9.355 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.36     | 106.36     | 106.36     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10044    | 0.10044    | 0.10044    |   0.0 |  0.09
Output  | 0.00021414 | 0.00021414 | 0.00021414 |   0.0 |  0.00
Modify  | 0.38014    | 0.38014    | 0.38014    |   0.0 |  0.36
Other   |            | 0.06123    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127950.0 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127950
Ave neighs/atom = 63.975000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.555340819037, Press = 4.05360527194935
next a
jump SELF top
variable a loop 2000
run 1000
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   -8033.1838   -8033.1838   -8114.0425   -8114.0425    312.93154    312.93154    24076.779    24076.779    1701.0252    1701.0252 
   24000   -8028.9886   -8028.9886   -8113.0115   -8113.0115     325.1775     325.1775     24096.57     24096.57    466.64078    466.64078 
Loop time of 112.696 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.13     | 112.13     | 112.13     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10407    | 0.10407    | 0.10407    |   0.0 |  0.09
Output  | 0.00016488 | 0.00016488 | 0.00016488 |   0.0 |  0.00
Modify  | 0.4014     | 0.4014     | 0.4014     |   0.0 |  0.36
Other   |            | 0.06296    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4118.00 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127964.0 ave      127964 max      127964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127964
Ave neighs/atom = 63.982000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.632194831821, Press = 7.02688669612929
next a
jump SELF top
variable a loop 2000
run 1000
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   -8028.9886   -8028.9886   -8113.0115   -8113.0115     325.1775     325.1775     24096.57     24096.57    466.64078    466.64078 
   25000   -8035.0262   -8035.0262   -8114.4742   -8114.4742     307.4721     307.4721    24115.259    24115.259   -1388.9503   -1388.9503 
Loop time of 112.689 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.303 hours/ns, 8.874 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.11     | 112.11     | 112.11     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10567    | 0.10567    | 0.10567    |   0.0 |  0.09
Output  | 0.00020229 | 0.00020229 | 0.00020229 |   0.0 |  0.00
Modify  | 0.40819    | 0.40819    | 0.40819    |   0.0 |  0.36
Other   |            | 0.06314    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127950.0 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127950
Ave neighs/atom = 63.975000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.77418439473, Press = 5.55540698213455
next a
jump SELF top
variable a loop 2000
run 1000
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.0262   -8035.0262   -8114.4742   -8114.4742     307.4721     307.4721    24115.259    24115.259   -1388.9503   -1388.9503 
   26000   -8036.1466   -8036.1466   -8113.9433   -8113.9433    301.08121    301.08121    24129.707    24129.707   -2484.4072   -2484.4072 
Loop time of 111.149 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.777 ns/day, 30.875 hours/ns, 8.997 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.58     | 110.58     | 110.58     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10341    | 0.10341    | 0.10341    |   0.0 |  0.09
Output  | 0.00015309 | 0.00015309 | 0.00015309 |   0.0 |  0.00
Modify  | 0.39897    | 0.39897    | 0.39897    |   0.0 |  0.36
Other   |            | 0.06279    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127960.0 ave      127960 max      127960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127960
Ave neighs/atom = 63.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.737354790873, Press = 0.0681367101167972
next a
jump SELF top
variable a loop 2000
run 1000
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   -8036.1466   -8036.1466   -8113.9433   -8113.9433    301.08121    301.08121    24129.707    24129.707   -2484.4072   -2484.4072 
   27000   -8031.5519   -8031.5519    -8111.951    -8111.951    311.15312    311.15312    24047.571    24047.571    4219.7142    4219.7142 
Loop time of 112.892 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.31     | 112.31     | 112.31     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10575    | 0.10575    | 0.10575    |   0.0 |  0.09
Output  | 0.00019294 | 0.00019294 | 0.00019294 |   0.0 |  0.00
Modify  | 0.40884    | 0.40884    | 0.40884    |   0.0 |  0.36
Other   |            | 0.06413    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127936.0 ave      127936 max      127936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127936
Ave neighs/atom = 63.968000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.69139959434, Press = 0.32233386483217
next a
jump SELF top
variable a loop 2000
run 1000
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   -8031.5519   -8031.5519    -8111.951    -8111.951    311.15312    311.15312    24047.571    24047.571    4219.7142    4219.7142 
   28000   -8034.9396   -8034.9396   -8115.1081   -8115.1081     310.2604     310.2604    24070.927    24070.927    1910.0035    1910.0035 
Loop time of 110.009 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.785 ns/day, 30.558 hours/ns, 9.090 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.45     | 109.45     | 109.45     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10302    | 0.10302    | 0.10302    |   0.0 |  0.09
Output  | 0.00026659 | 0.00026659 | 0.00026659 |   0.0 |  0.00
Modify  | 0.39412    | 0.39412    | 0.39412    |   0.0 |  0.36
Other   |            | 0.06263    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127972.0 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.60008321995, Press = 6.76255403117256
next a
jump SELF top
variable a loop 2000
run 1000
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   -8034.9396   -8034.9396   -8115.1081   -8115.1081     310.2604     310.2604    24070.927    24070.927    1910.0035    1910.0035 
   29000   -8034.1726   -8034.1726   -8116.4532   -8116.4532    318.43472    318.43472    24114.042    24114.042   -1539.3675   -1539.3675 
Loop time of 112.026 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.46     | 111.46     | 111.46     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10453    | 0.10453    | 0.10453    |   0.0 |  0.09
Output  | 0.0001534  | 0.0001534  | 0.0001534  |   0.0 |  0.00
Modify  | 0.40022    | 0.40022    | 0.40022    |   0.0 |  0.36
Other   |            | 0.06296    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127972.0 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.605053600727, Press = 5.61310223798098
next a
jump SELF top
variable a loop 2000
run 1000
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   -8034.1726   -8034.1726   -8116.4532   -8116.4532    318.43472    318.43472    24114.042    24114.042   -1539.3675   -1539.3675 
   30000   -8033.9251   -8033.9251   -8114.7554   -8114.7554    312.82195    312.82195    24116.905    24116.905   -1551.3221   -1551.3221 
Loop time of 110.538 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.782 ns/day, 30.705 hours/ns, 9.047 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.97     | 109.97     | 109.97     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10395    | 0.10395    | 0.10395    |   0.0 |  0.09
Output  | 0.00042416 | 0.00042416 | 0.00042416 |   0.0 |  0.00
Modify  | 0.39736    | 0.39736    | 0.39736    |   0.0 |  0.36
Other   |            | 0.06279    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127964.0 ave      127964 max      127964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127964
Ave neighs/atom = 63.982000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.645874176377, Press = 2.33059037060541
next a
jump SELF top
variable a loop 2000
run 1000
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   -8033.9251   -8033.9251   -8114.7554   -8114.7554    312.82195    312.82195    24116.905    24116.905   -1551.3221   -1551.3221 
   31000    -8028.716    -8028.716   -8111.7474   -8111.7474    321.34017    321.34017    24082.678    24082.678    1623.5119    1623.5119 
Loop time of 109.303 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.362 hours/ns, 9.149 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.75     | 108.75     | 108.75     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10205    | 0.10205    | 0.10205    |   0.0 |  0.09
Output  | 0.00015304 | 0.00015304 | 0.00015304 |   0.0 |  0.00
Modify  | 0.38967    | 0.38967    | 0.38967    |   0.0 |  0.36
Other   |            | 0.0613     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127960.0 ave      127960 max      127960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127960
Ave neighs/atom = 63.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.737154630549, Press = 2.74102683224549
next a
jump SELF top
variable a loop 2000
run 1000
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    -8028.716    -8028.716   -8111.7474   -8111.7474    321.34017    321.34017    24082.678    24082.678    1623.5119    1623.5119 
   32000   -8033.0846   -8033.0846   -8111.6545   -8111.6545    304.07387    304.07387    24079.977    24079.977    1675.8412    1675.8412 
Loop time of 113.25 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.67     | 112.67     | 112.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10527    | 0.10527    | 0.10527    |   0.0 |  0.09
Output  | 0.00015002 | 0.00015002 | 0.00015002 |   0.0 |  0.00
Modify  | 0.40984    | 0.40984    | 0.40984    |   0.0 |  0.36
Other   |            | 0.06346    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127946.0 ave      127946 max      127946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127946
Ave neighs/atom = 63.973000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.795963872726, Press = 5.40991639642288
next a
jump SELF top
variable a loop 2000
run 1000
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.0846   -8033.0846   -8111.6545   -8111.6545    304.07387    304.07387    24079.977    24079.977    1675.8412    1675.8412 
   33000   -8033.7553   -8033.7553   -8116.0097   -8116.0097    318.33317    318.33317    24115.244    24115.244   -1528.5726   -1528.5726 
Loop time of 112.874 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.29     | 112.29     | 112.29     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10564    | 0.10564    | 0.10564    |   0.0 |  0.09
Output  | 0.00015543 | 0.00015543 | 0.00015543 |   0.0 |  0.00
Modify  | 0.41134    | 0.41134    | 0.41134    |   0.0 |  0.36
Other   |            | 0.06354    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127972.0 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.82520473472, Press = 4.23041992339181
next a
jump SELF top
variable a loop 2000
run 1000
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   -8033.7553   -8033.7553   -8116.0097   -8116.0097    318.33317    318.33317    24115.244    24115.244   -1528.5726   -1528.5726 
   34000   -8034.3846   -8034.3846   -8115.4331   -8115.4331    313.66602    313.66602    24103.284    24103.284   -605.34858   -605.34858 
Loop time of 114.184 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.718 hours/ns, 8.758 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.6      | 113.6      | 113.6      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10591    | 0.10591    | 0.10591    |   0.0 |  0.09
Output  | 0.00015273 | 0.00015273 | 0.00015273 |   0.0 |  0.00
Modify  | 0.41089    | 0.41089    | 0.41089    |   0.0 |  0.36
Other   |            | 0.06337    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127964.0 ave      127964 max      127964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127964
Ave neighs/atom = 63.982000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.74159097585, Press = 2.71266592820251
next a
jump SELF top
variable a loop 2000
run 1000
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   -8034.3846   -8034.3846   -8115.4331   -8115.4331    313.66602    313.66602    24103.284    24103.284   -605.34858   -605.34858 
   35000   -8031.7802   -8031.7802   -8114.3602   -8114.3602    319.59305    319.59305    24092.231    24092.231    549.34444    549.34444 
Loop time of 111.34 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.776 ns/day, 30.928 hours/ns, 8.981 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.77     | 110.77     | 110.77     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10438    | 0.10438    | 0.10438    |   0.0 |  0.09
Output  | 0.00015304 | 0.00015304 | 0.00015304 |   0.0 |  0.00
Modify  | 0.40231    | 0.40231    | 0.40231    |   0.0 |  0.36
Other   |            | 0.06297    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127952.0 ave      127952 max      127952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127952
Ave neighs/atom = 63.976000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.785998832175, Press = 2.91948362710848
next a
jump SELF top
variable a loop 2000
run 1000
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   -8031.7802   -8031.7802   -8114.3602   -8114.3602    319.59305    319.59305    24092.231    24092.231    549.34444    549.34444 
   36000    -8031.728    -8031.728   -8113.1274   -8113.1274    315.02395    315.02395     24097.78     24097.78    199.28338    199.28338 
Loop time of 106.496 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.582 hours/ns, 9.390 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.96     | 105.96     | 105.96     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1001     | 0.1001     | 0.1001     |   0.0 |  0.09
Output  | 0.00020204 | 0.00020204 | 0.00020204 |   0.0 |  0.00
Modify  | 0.37637    | 0.37637    | 0.37637    |   0.0 |  0.35
Other   |            | 0.06059    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127964.0 ave      127964 max      127964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127964
Ave neighs/atom = 63.982000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.799733933511, Press = 3.43735838789556
next a
jump SELF top
variable a loop 2000
run 1000
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    -8031.728    -8031.728   -8113.1274   -8113.1274    315.02395    315.02395     24097.78     24097.78    199.28338    199.28338 
   37000   -8036.0819   -8036.0819   -8115.2792   -8115.2792    306.50171    306.50171    24095.732    24095.732    -16.66659    -16.66659 
Loop time of 109.389 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.386 hours/ns, 9.142 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.84     | 108.84     | 108.84     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10236    | 0.10236    | 0.10236    |   0.0 |  0.09
Output  | 0.00021099 | 0.00021099 | 0.00021099 |   0.0 |  0.00
Modify  | 0.38861    | 0.38861    | 0.38861    |   0.0 |  0.36
Other   |            | 0.0613     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127942.0 ave      127942 max      127942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127942
Ave neighs/atom = 63.971000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.828431178357, Press = 2.74065713163282
next a
jump SELF top
variable a loop 2000
run 1000
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.0819   -8036.0819   -8115.2792   -8115.2792    306.50171    306.50171    24095.732    24095.732    -16.66659    -16.66659 
   38000   -8031.2037   -8031.2037   -8114.1655   -8114.1655    321.07092    321.07092    24098.691    24098.691    70.344769    70.344769 
Loop time of 115.055 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.751 ns/day, 31.960 hours/ns, 8.691 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.46     | 114.46     | 114.46     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10719    | 0.10719    | 0.10719    |   0.0 |  0.09
Output  | 0.0001543  | 0.0001543  | 0.0001543  |   0.0 |  0.00
Modify  | 0.41987    | 0.41987    | 0.41987    |   0.0 |  0.36
Other   |            | 0.06485    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127944.0 ave      127944 max      127944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127944
Ave neighs/atom = 63.972000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.841570141351, Press = 2.79177337173536
next a
jump SELF top
variable a loop 2000
run 1000
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   -8031.2037   -8031.2037   -8114.1655   -8114.1655    321.07092    321.07092    24098.691    24098.691    70.344769    70.344769 
   39000   -8034.1903   -8034.1903   -8114.0386   -8114.0386    309.02108    309.02108    24093.156    24093.156    337.99878    337.99878 
Loop time of 113.413 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.504 hours/ns, 8.817 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.83     | 112.83     | 112.83     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10688    | 0.10688    | 0.10688    |   0.0 |  0.09
Output  | 0.00015358 | 0.00015358 | 0.00015358 |   0.0 |  0.00
Modify  | 0.41035    | 0.41035    | 0.41035    |   0.0 |  0.36
Other   |            | 0.06417    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127946.0 ave      127946 max      127946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127946
Ave neighs/atom = 63.973000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.885774000184, Press = 3.30926127317541
next a
jump SELF top
variable a loop 2000
run 1000
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   -8034.1903   -8034.1903   -8114.0386   -8114.0386    309.02108    309.02108    24093.156    24093.156    337.99878    337.99878 
   40000   -8035.8893   -8035.8893   -8114.0442   -8114.0442    302.46755    302.46755    24117.559    24117.559   -1545.6051   -1545.6051 
Loop time of 111.712 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.773 ns/day, 31.031 hours/ns, 8.952 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.14     | 111.14     | 111.14     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10543    | 0.10543    | 0.10543    |   0.0 |  0.09
Output  | 0.00015423 | 0.00015423 | 0.00015423 |   0.0 |  0.00
Modify  | 0.40242    | 0.40242    | 0.40242    |   0.0 |  0.36
Other   |            | 0.06249    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127958.0 ave      127958 max      127958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127958
Ave neighs/atom = 63.979000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.932392872667, Press = 2.98718672782542
next a
jump SELF top
variable a loop 2000
run 1000
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   -8035.8893   -8035.8893   -8114.0442   -8114.0442    302.46755    302.46755    24117.559    24117.559   -1545.6051   -1545.6051 
   41000   -8033.3182   -8033.3182   -8115.9479   -8115.9479    319.78543    319.78543    24116.622    24116.622   -1513.3864   -1513.3864 
Loop time of 114.335 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.760 hours/ns, 8.746 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.75     | 113.75     | 113.75     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10619    | 0.10619    | 0.10619    |   0.0 |  0.09
Output  | 0.00021452 | 0.00021452 | 0.00021452 |   0.0 |  0.00
Modify  | 0.41322    | 0.41322    | 0.41322    |   0.0 |  0.36
Other   |            | 0.0642     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127968.0 ave      127968 max      127968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127968
Ave neighs/atom = 63.984000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.864739459238, Press = 0.763687174359922
next a
jump SELF top
variable a loop 2000
run 1000
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   -8033.3182   -8033.3182   -8115.9479   -8115.9479    319.78543    319.78543    24116.622    24116.622   -1513.3864   -1513.3864 
   42000   -8034.5174   -8034.5174   -8114.5515   -8114.5515    309.74047    309.74047     24059.64     24059.64    2901.3648    2901.3648 
Loop time of 113.622 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.562 hours/ns, 8.801 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.04     | 113.04     | 113.04     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10516    | 0.10516    | 0.10516    |   0.0 |  0.09
Output  | 0.00015991 | 0.00015991 | 0.00015991 |   0.0 |  0.00
Modify  | 0.40937    | 0.40937    | 0.40937    |   0.0 |  0.36
Other   |            | 0.06373    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127956.0 ave      127956 max      127956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127956
Ave neighs/atom = 63.978000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.845183139519, Press = 1.4645827204163
next a
jump SELF top
variable a loop 2000
run 1000
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   -8034.5174   -8034.5174   -8114.5515   -8114.5515    309.74047    309.74047     24059.64     24059.64    2901.3648    2901.3648 
   43000   -8033.5502   -8033.5502   -8114.3787   -8114.3787    312.81472    312.81472    24071.882    24071.882    1886.1087    1886.1087 
Loop time of 110.262 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.784 ns/day, 30.628 hours/ns, 9.069 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.69     | 109.69     | 109.69     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.104      | 0.104      | 0.104      |   0.0 |  0.09
Output  | 0.00015323 | 0.00015323 | 0.00015323 |   0.0 |  0.00
Modify  | 0.4013     | 0.4013     | 0.4013     |   0.0 |  0.36
Other   |            | 0.06299    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127972.0 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.783844558105, Press = 4.43078172243075
next a
jump SELF top
variable a loop 2000
run 1000
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   -8033.5502   -8033.5502   -8114.3787   -8114.3787    312.81472    312.81472    24071.882    24071.882    1886.1087    1886.1087 
   44000   -8033.2797   -8033.2797    -8113.093    -8113.093    308.88543    308.88543    24116.523    24116.523   -1289.5949   -1289.5949 
Loop time of 112.359 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.78     | 111.78     | 111.78     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10566    | 0.10566    | 0.10566    |   0.0 |  0.09
Output  | 0.00015267 | 0.00015267 | 0.00015267 |   0.0 |  0.00
Modify  | 0.40516    | 0.40516    | 0.40516    |   0.0 |  0.36
Other   |            | 0.06376    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127960.0 ave      127960 max      127960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127960
Ave neighs/atom = 63.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.777785584023, Press = 2.91824240077459
next a
jump SELF top
variable a loop 2000
run 1000
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   -8033.2797   -8033.2797    -8113.093    -8113.093    308.88543    308.88543    24116.523    24116.523   -1289.5949   -1289.5949 
   45000   -8035.2925   -8035.2925   -8116.6112   -8116.6112    314.71188    314.71188     24103.15     24103.15   -832.39198   -832.39198 
Loop time of 109.247 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.346 hours/ns, 9.154 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.69     | 108.69     | 108.69     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10294    | 0.10294    | 0.10294    |   0.0 |  0.09
Output  | 0.00015366 | 0.00015366 | 0.00015366 |   0.0 |  0.00
Modify  | 0.3907     | 0.3907     | 0.3907     |   0.0 |  0.36
Other   |            | 0.06194    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127928.0 ave      127928 max      127928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127928
Ave neighs/atom = 63.964000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.70351511017, Press = 1.80829758220136
next a
jump SELF top
variable a loop 2000
run 1000
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.2925   -8035.2925   -8116.6112   -8116.6112    314.71188    314.71188     24103.15     24103.15   -832.39198   -832.39198 
   46000   -8033.0147   -8033.0147   -8115.5098   -8115.5098    319.26465    319.26465    24086.549    24086.549     878.6648     878.6648 
Loop time of 111.04 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.778 ns/day, 30.845 hours/ns, 9.006 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.48     | 110.48     | 110.48     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10383    | 0.10383    | 0.10383    |   0.0 |  0.09
Output  | 0.00015405 | 0.00015405 | 0.00015405 |   0.0 |  0.00
Modify  | 0.39732    | 0.39732    | 0.39732    |   0.0 |  0.36
Other   |            | 0.06266    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127950.0 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127950
Ave neighs/atom = 63.975000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.708672524436, Press = 2.11045401152572
next a
jump SELF top
variable a loop 2000
run 1000
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   -8033.0147   -8033.0147   -8115.5098   -8115.5098    319.26465    319.26465    24086.549    24086.549     878.6648     878.6648 
   47000   -8035.7258   -8035.7258   -8116.1867   -8116.1867    311.39194    311.39194     24093.13     24093.13     152.8763     152.8763 
Loop time of 107.466 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.92     | 106.92     | 106.92     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10076    | 0.10076    | 0.10076    |   0.0 |  0.09
Output  | 0.00015341 | 0.00015341 | 0.00015341 |   0.0 |  0.00
Modify  | 0.38012    | 0.38012    | 0.38012    |   0.0 |  0.35
Other   |            | 0.06059    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127966.0 ave      127966 max      127966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127966
Ave neighs/atom = 63.983000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.636517622118, Press = 3.14537653522207
next a
jump SELF top
variable a loop 2000
run 1000
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   -8035.7258   -8035.7258   -8116.1867   -8116.1867    311.39194    311.39194     24093.13     24093.13     152.8763     152.8763 
   48000   -8032.6636   -8032.6636   -8113.1866   -8113.1866    311.63213    311.63213     24142.77     24142.77   -3266.2896   -3266.2896 
Loop time of 108.322 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.798 ns/day, 30.089 hours/ns, 9.232 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.77     | 107.77     | 107.77     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10251    | 0.10251    | 0.10251    |   0.0 |  0.09
Output  | 0.00015518 | 0.00015518 | 0.00015518 |   0.0 |  0.00
Modify  | 0.38609    | 0.38609    | 0.38609    |   0.0 |  0.36
Other   |            | 0.06163    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127964.0 ave      127964 max      127964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127964
Ave neighs/atom = 63.982000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.633471002439, Press = 1.93441324063025
next a
jump SELF top
variable a loop 2000
run 1000
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   -8032.6636   -8032.6636   -8113.1866   -8113.1866    311.63213    311.63213     24142.77     24142.77   -3266.2896   -3266.2896 
   49000   -8029.6595   -8029.6595    -8112.825    -8112.825    321.85901    321.85901    24104.126    24104.126   -186.68933   -186.68933 
Loop time of 109.414 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.393 hours/ns, 9.140 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.85     | 108.85     | 108.85     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10328    | 0.10328    | 0.10328    |   0.0 |  0.09
Output  | 0.00019368 | 0.00019368 | 0.00019368 |   0.0 |  0.00
Modify  | 0.39404    | 0.39404    | 0.39404    |   0.0 |  0.36
Other   |            | 0.06219    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127946.0 ave      127946 max      127946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127946
Ave neighs/atom = 63.973000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.62906807969, Press = 0.103471567928528
next a
jump SELF top
variable a loop 2000
run 1000
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   -8029.6595   -8029.6595    -8112.825    -8112.825    321.85901    321.85901    24104.126    24104.126   -186.68933   -186.68933 
   50000   -8033.2681   -8033.2681   -8112.8635   -8112.8635    308.04234    308.04234    24064.479    24064.479    2720.7607    2720.7607 
Loop time of 105.492 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.303 hours/ns, 9.479 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.96     | 104.96     | 104.96     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099662   | 0.099662   | 0.099662   |   0.0 |  0.09
Output  | 0.0001553  | 0.0001553  | 0.0001553  |   0.0 |  0.00
Modify  | 0.37152    | 0.37152    | 0.37152    |   0.0 |  0.35
Other   |            | 0.06019    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127966.0 ave      127966 max      127966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127966
Ave neighs/atom = 63.983000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.692015460085, Press = 2.10505708701884
next a
jump SELF top
variable a loop 2000
run 1000
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   -8033.2681   -8033.2681   -8112.8635   -8112.8635    308.04234    308.04234    24064.479    24064.479    2720.7607    2720.7607 
   51000   -8031.1022   -8031.1022   -8112.7787   -8112.7787    316.09683    316.09683    24100.808    24100.808    131.94822    131.94822 
Loop time of 107.174 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.806 ns/day, 29.771 hours/ns, 9.331 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.64     | 106.64     | 106.64     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10109    | 0.10109    | 0.10109    |   0.0 |  0.09
Output  | 0.00023771 | 0.00023771 | 0.00023771 |   0.0 |  0.00
Modify  | 0.37598    | 0.37598    | 0.37598    |   0.0 |  0.35
Other   |            | 0.06131    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127978.0 ave      127978 max      127978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127978
Ave neighs/atom = 63.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.734184548541, Press = 2.73428370896126
next a
jump SELF top
variable a loop 2000
run 1000
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.1022   -8031.1022   -8112.7787   -8112.7787    316.09683    316.09683    24100.808    24100.808    131.94822    131.94822 
   52000   -8034.8303   -8034.8303   -8114.2778   -8114.2778    307.46999    307.46999    24106.761    24106.761   -579.97853   -579.97853 
Loop time of 110.383 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.783 ns/day, 30.662 hours/ns, 9.059 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.82     | 109.82     | 109.82     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10371    | 0.10371    | 0.10371    |   0.0 |  0.09
Output  | 0.00015459 | 0.00015459 | 0.00015459 |   0.0 |  0.00
Modify  | 0.39604    | 0.39604    | 0.39604    |   0.0 |  0.36
Other   |            | 0.06231    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127958.0 ave      127958 max      127958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127958
Ave neighs/atom = 63.979000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.752082052002, Press = 2.04648414811958
next a
jump SELF top
variable a loop 2000
run 1000
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   -8034.8303   -8034.8303   -8114.2778   -8114.2778    307.46999    307.46999    24106.761    24106.761   -579.97853   -579.97853 
   53000   -8031.5461   -8031.5461   -8112.5699   -8112.5699    313.57048    313.57048    24104.212    24104.212   -135.81201   -135.81201 
Loop time of 107.222 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.806 ns/day, 29.784 hours/ns, 9.326 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.68     | 106.68     | 106.68     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10077    | 0.10077    | 0.10077    |   0.0 |  0.09
Output  | 0.00019022 | 0.00019022 | 0.00019022 |   0.0 |  0.00
Modify  | 0.38186    | 0.38186    | 0.38186    |   0.0 |  0.36
Other   |            | 0.06126    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127950.0 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127950
Ave neighs/atom = 63.975000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.817278300523, Press = 1.26920004289729
next a
jump SELF top
variable a loop 2000
run 1000
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   -8031.5461   -8031.5461   -8112.5699   -8112.5699    313.57048    313.57048    24104.212    24104.212   -135.81201   -135.81201 
   54000   -8031.8886   -8031.8886   -8113.9146   -8113.9146    317.44921    317.44921    24095.558    24095.558    350.65293    350.65293 
Loop time of 111.486 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.775 ns/day, 30.968 hours/ns, 8.970 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.92     | 110.92     | 110.92     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10361    | 0.10361    | 0.10361    |   0.0 |  0.09
Output  | 0.00021455 | 0.00021455 | 0.00021455 |   0.0 |  0.00
Modify  | 0.39649    | 0.39649    | 0.39649    |   0.0 |  0.36
Other   |            | 0.06304    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127974.0 ave      127974 max      127974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127974
Ave neighs/atom = 63.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.833312233682, Press = 1.5991316352979
next a
jump SELF top
variable a loop 2000
run 1000
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   -8031.8886   -8031.8886   -8113.9146   -8113.9146    317.44921    317.44921    24095.558    24095.558    350.65293    350.65293 
   55000   -8032.4989   -8032.4989   -8111.9149   -8111.9149    307.34817    307.34817    24095.645    24095.645    386.24085    386.24085 
Loop time of 109.129 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.792 ns/day, 30.314 hours/ns, 9.163 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.58     | 108.58     | 108.58     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10199    | 0.10199    | 0.10199    |   0.0 |  0.09
Output  | 0.00019746 | 0.00019746 | 0.00019746 |   0.0 |  0.00
Modify  | 0.38819    | 0.38819    | 0.38819    |   0.0 |  0.36
Other   |            | 0.06182    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127956.0 ave      127956 max      127956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127956
Ave neighs/atom = 63.978000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.906683775497, Press = 1.68292206094969
next a
jump SELF top
variable a loop 2000
run 1000
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   -8032.4989   -8032.4989   -8111.9149   -8111.9149    307.34817    307.34817    24095.645    24095.645    386.24085    386.24085 
   56000   -8031.7731   -8031.7731   -8114.9114   -8114.9114    321.75345    321.75345    24104.853    24104.853   -575.27799   -575.27799 
Loop time of 114.979 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.751 ns/day, 31.939 hours/ns, 8.697 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.39     | 114.39     | 114.39     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10734    | 0.10734    | 0.10734    |   0.0 |  0.09
Output  | 0.00019899 | 0.00019899 | 0.00019899 |   0.0 |  0.00
Modify  | 0.42014    | 0.42014    | 0.42014    |   0.0 |  0.37
Other   |            | 0.06428    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127942.0 ave      127942 max      127942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127942
Ave neighs/atom = 63.971000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.892003432572, Press = 1.75635226729667
next a
jump SELF top
variable a loop 2000
run 1000
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   -8031.7731   -8031.7731   -8114.9114   -8114.9114    321.75345    321.75345    24104.853    24104.853   -575.27799   -575.27799 
   57000   -8032.3897   -8032.3897   -8113.0562   -8113.0562    312.18775    312.18775    24113.261    24113.261    -1093.755    -1093.755 
Loop time of 112.29 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.769 ns/day, 31.192 hours/ns, 8.906 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.71     | 111.71     | 111.71     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10524    | 0.10524    | 0.10524    |   0.0 |  0.09
Output  | 0.00021183 | 0.00021183 | 0.00021183 |   0.0 |  0.00
Modify  | 0.40798    | 0.40798    | 0.40798    |   0.0 |  0.36
Other   |            | 0.06314    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4114.00 ave        4114 max        4114 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127944.0 ave      127944 max      127944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127944
Ave neighs/atom = 63.972000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.872482176962, Press = 1.02422462369335
next a
jump SELF top
variable a loop 2000
run 1000
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   -8032.3897   -8032.3897   -8113.0562   -8113.0562    312.18775    312.18775    24113.261    24113.261    -1093.755    -1093.755 
   58000   -8027.8898   -8027.8898   -8111.9424   -8111.9424     325.2924     325.2924    24088.838    24088.838      1112.87      1112.87 
Loop time of 115.672 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.747 ns/day, 32.131 hours/ns, 8.645 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.08     | 115.08     | 115.08     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10728    | 0.10728    | 0.10728    |   0.0 |  0.09
Output  | 0.00018768 | 0.00018768 | 0.00018768 |   0.0 |  0.00
Modify  | 0.42355    | 0.42355    | 0.42355    |   0.0 |  0.37
Other   |            | 0.06463    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127968.0 ave      127968 max      127968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127968
Ave neighs/atom = 63.984000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.883464335805, Press = 0.558583221148334
next a
jump SELF top
variable a loop 2000
run 1000
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   -8027.8898   -8027.8898   -8111.9424   -8111.9424     325.2924     325.2924    24088.838    24088.838      1112.87      1112.87 
   59000   -8033.4832   -8033.4832    -8115.044    -8115.044    315.64903    315.64903    24063.274    24063.274    2593.2546    2593.2546 
Loop time of 109.226 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.340 hours/ns, 9.155 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.67     | 108.67     | 108.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10293    | 0.10293    | 0.10293    |   0.0 |  0.09
Output  | 0.00026106 | 0.00026106 | 0.00026106 |   0.0 |  0.00
Modify  | 0.38867    | 0.38867    | 0.38867    |   0.0 |  0.36
Other   |            | 0.06159    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127944.0 ave      127944 max      127944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127944
Ave neighs/atom = 63.972000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.932961214109, Press = 2.2671819382865
next a
jump SELF top
variable a loop 2000
run 1000
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.4832   -8033.4832    -8115.044    -8115.044    315.64903    315.64903    24063.274    24063.274    2593.2546    2593.2546 
   60000   -8030.6252   -8030.6252   -8111.5332   -8111.5332    313.12227    313.12227    24116.666    24116.666      -1134.1      -1134.1 
Loop time of 108.241 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.798 ns/day, 30.067 hours/ns, 9.239 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.69     | 107.69     | 107.69     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10187    | 0.10187    | 0.10187    |   0.0 |  0.09
Output  | 0.00019802 | 0.00019802 | 0.00019802 |   0.0 |  0.00
Modify  | 0.38743    | 0.38743    | 0.38743    |   0.0 |  0.36
Other   |            | 0.06192    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127948.0 ave      127948 max      127948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127948
Ave neighs/atom = 63.974000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.95645021833, Press = 2.47613440167424
next a
jump SELF top
variable a loop 2000
run 1000
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   -8030.6252   -8030.6252   -8111.5332   -8111.5332    313.12227    313.12227    24116.666    24116.666      -1134.1      -1134.1 
   61000   -8032.7597   -8032.7597   -8114.6677   -8114.6677    316.99262    316.99262    24122.695    24122.695   -1842.7545   -1842.7545 
Loop time of 115.104 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.751 ns/day, 31.973 hours/ns, 8.688 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.51     | 114.51     | 114.51     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10712    | 0.10712    | 0.10712    |   0.0 |  0.09
Output  | 0.00023973 | 0.00023973 | 0.00023973 |   0.0 |  0.00
Modify  | 0.41802    | 0.41802    | 0.41802    |   0.0 |  0.36
Other   |            | 0.06513    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127966.0 ave      127966 max      127966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127966
Ave neighs/atom = 63.983000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.930446688469, Press = 0.866190429372373
next a
jump SELF top
variable a loop 2000
run 1000
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   -8032.7597   -8032.7597   -8114.6677   -8114.6677    316.99262    316.99262    24122.695    24122.695   -1842.7545   -1842.7545 
   62000   -8032.2151   -8032.2151   -8114.0797   -8114.0797    316.82413    316.82413    24090.709    24090.709    651.77698    651.77698 
Loop time of 111.45 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.775 ns/day, 30.958 hours/ns, 8.973 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.88     | 110.88     | 110.88     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10422    | 0.10422    | 0.10422    |   0.0 |  0.09
Output  | 0.00015273 | 0.00015273 | 0.00015273 |   0.0 |  0.00
Modify  | 0.40116    | 0.40116    | 0.40116    |   0.0 |  0.36
Other   |            | 0.06342    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4118.00 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127950.0 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127950
Ave neighs/atom = 63.975000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.956771006074, Press = 0.96624297787497
next a
jump SELF top
variable a loop 2000
run 1000
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   -8032.2151   -8032.2151   -8114.0797   -8114.0797    316.82413    316.82413    24090.709    24090.709    651.77698    651.77698 
   63000   -8033.0391   -8033.0391   -8115.3901   -8115.3901    318.70688    318.70688    24093.088    24093.088    367.85693    367.85693 
Loop time of 107.82 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.801 ns/day, 29.950 hours/ns, 9.275 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.27     | 107.27     | 107.27     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10177    | 0.10177    | 0.10177    |   0.0 |  0.09
Output  | 0.0002077  | 0.0002077  | 0.0002077  |   0.0 |  0.00
Modify  | 0.3831     | 0.3831     | 0.3831     |   0.0 |  0.36
Other   |            | 0.06168    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127950.0 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127950
Ave neighs/atom = 63.975000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.965778966852, Press = 1.54456126565792
next a
jump SELF top
variable a loop 2000
run 1000
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   -8033.0391   -8033.0391   -8115.3901   -8115.3901    318.70688    318.70688    24093.088    24093.088    367.85693    367.85693 
   64000   -8028.9443   -8028.9443   -8111.2453   -8111.2453    318.51348    318.51348        24109        24109   -386.08295   -386.08295 
Loop time of 113.263 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.462 hours/ns, 8.829 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.69     | 112.69     | 112.69     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1038     | 0.1038     | 0.1038     |   0.0 |  0.09
Output  | 0.00022334 | 0.00022334 | 0.00022334 |   0.0 |  0.00
Modify  | 0.40681    | 0.40681    | 0.40681    |   0.0 |  0.36
Other   |            | 0.06379    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127952.0 ave      127952 max      127952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127952
Ave neighs/atom = 63.976000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.019767598066, Press = 1.46790016523211
next a
jump SELF top
variable a loop 2000
run 1000
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   -8028.9443   -8028.9443   -8111.2453   -8111.2453    318.51348    318.51348        24109        24109   -386.08295   -386.08295 
   65000   -8034.5623   -8034.5623    -8115.461    -8115.461    313.08652    313.08652    24110.203    24110.203   -1140.7483   -1140.7483 
Loop time of 110.954 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.779 ns/day, 30.821 hours/ns, 9.013 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.39     | 110.39     | 110.39     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10342    | 0.10342    | 0.10342    |   0.0 |  0.09
Output  | 0.00015325 | 0.00015325 | 0.00015325 |   0.0 |  0.00
Modify  | 0.39623    | 0.39623    | 0.39623    |   0.0 |  0.36
Other   |            | 0.06273    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127948.0 ave      127948 max      127948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127948
Ave neighs/atom = 63.974000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.033685211353, Press = 0.77548159472234
next a
jump SELF top
variable a loop 2000
run 1000
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   -8034.5623   -8034.5623    -8115.461    -8115.461    313.08652    313.08652    24110.203    24110.203   -1140.7483   -1140.7483 
   66000   -8031.5059   -8031.5059   -8113.6323   -8113.6323    317.83762    317.83762    24082.808    24082.808    1279.0688    1279.0688 
Loop time of 117.084 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.738 ns/day, 32.523 hours/ns, 8.541 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.48     | 116.48     | 116.48     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10815    | 0.10815    | 0.10815    |   0.0 |  0.09
Output  | 0.00023632 | 0.00023632 | 0.00023632 |   0.0 |  0.00
Modify  | 0.42873    | 0.42873    | 0.42873    |   0.0 |  0.37
Other   |            | 0.06572    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127960.0 ave      127960 max      127960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127960
Ave neighs/atom = 63.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.080709076027, Press = 0.799108182059808
next a
jump SELF top
variable a loop 2000
run 1000
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   -8031.5059   -8031.5059   -8113.6323   -8113.6323    317.83762    317.83762    24082.808    24082.808    1279.0688    1279.0688 
   67000   -8031.9249   -8031.9249   -8113.6734   -8113.6734    316.37503    316.37503     24079.38     24079.38    1518.7853    1518.7853 
Loop time of 111.256 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.777 ns/day, 30.905 hours/ns, 8.988 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.7      | 110.7      | 110.7      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10226    | 0.10226    | 0.10226    |   0.0 |  0.09
Output  | 0.00015221 | 0.00015221 | 0.00015221 |   0.0 |  0.00
Modify  | 0.39477    | 0.39477    | 0.39477    |   0.0 |  0.35
Other   |            | 0.06299    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127972.0 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.089731959568, Press = 1.89760463118244
next a
jump SELF top
variable a loop 2000
run 1000
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 
   67000   -8031.9249   -8031.9249   -8113.6734   -8113.6734    316.37503    316.37503     24079.38     24079.38    1518.7853    1518.7853 
   68000   -8033.2198   -8033.2198   -8114.4937   -8114.4937    314.53834    314.53834     24128.26     24128.26   -2395.1134   -2395.1134 
Loop time of 112.69 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.303 hours/ns, 8.874 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.12     | 112.12     | 112.12     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10393    | 0.10393    | 0.10393    |   0.0 |  0.09
Output  | 0.00016284 | 0.00016284 | 0.00016284 |   0.0 |  0.00
Modify  | 0.40265    | 0.40265    | 0.40265    |   0.0 |  0.36
Other   |            | 0.0637     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127950.0 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127950
Ave neighs/atom = 63.975000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.13749022962, Press = 1.93132896636839
next a
jump SELF top
variable a loop 2000
run 1000
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 
   68000   -8033.2198   -8033.2198   -8114.4937   -8114.4937    314.53834    314.53834     24128.26     24128.26   -2395.1134   -2395.1134 
   69000   -8030.7217   -8030.7217   -8111.5395   -8111.5395    312.77316    312.77316     24135.39     24135.39   -2493.8758   -2493.8758 
Loop time of 109.738 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.483 hours/ns, 9.113 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.18     | 109.18     | 109.18     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10299    | 0.10299    | 0.10299    |   0.0 |  0.09
Output  | 0.00015213 | 0.00015213 | 0.00015213 |   0.0 |  0.00
Modify  | 0.39326    | 0.39326    | 0.39326    |   0.0 |  0.36
Other   |            | 0.06285    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127956.0 ave      127956 max      127956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127956
Ave neighs/atom = 63.978000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.132757020586, Press = 0.22721858287102
next a
jump SELF top
variable a loop 2000
run 1000
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 
   69000   -8030.7217   -8030.7217   -8111.5395   -8111.5395    312.77316    312.77316     24135.39     24135.39   -2493.8758   -2493.8758 
   70000   -8035.7345   -8035.7345   -8115.3022   -8115.3022    307.93524    307.93524    24068.336    24068.336    2004.6037    2004.6037 
Loop time of 110.727 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.780 ns/day, 30.758 hours/ns, 9.031 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.16     | 110.16     | 110.16     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1037     | 0.1037     | 0.1037     |   0.0 |  0.09
Output  | 0.00015354 | 0.00015354 | 0.00015354 |   0.0 |  0.00
Modify  | 0.39618    | 0.39618    | 0.39618    |   0.0 |  0.36
Other   |            | 0.06255    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127950.0 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0