# 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.8809780031442638*${_u_distance}
variable latticeconst_converted equal 2.8809780031442638*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.88097800314426
Lattice spacing in x,y,z = 2.8809780 2.8809780 2.8809780
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.809780 28.809780 28.809780)
  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.809780 28.809780 28.809780)
  create_atoms CPU = 0.003 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_WuLeeSu_2017_NiCrFe__MO_912636107108_001
pair_coeff * * Cr
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 51.9961

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23912.2161128496 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_912636107108_001#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    -8113.917    -8113.917        -8200        -8200       333.15       333.15    23912.216    23912.216    3845.1974    3845.1974 
    1000   -8023.5714   -8023.5714   -8112.0891   -8112.0891    342.57266    342.57266    24162.447    24162.447    2790.3893    2790.3893 
Loop time of 104.311 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.975 hours/ns, 9.587 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    | 103.78     | 103.78     | 103.78     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10147    | 0.10147    | 0.10147    |   0.0 |  0.10
Output  | 0.00023825 | 0.00023825 | 0.00023825 |   0.0 |  0.00
Modify  | 0.36518    | 0.36518    | 0.36518    |   0.0 |  0.35
Other   |            | 0.06108    |            |       |  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   -8023.5714   -8023.5714   -8112.0891   -8112.0891    342.57266    342.57266    24162.447    24162.447    2790.3893    2790.3893 
    2000   -8023.8531   -8023.8531   -8113.0504   -8113.0504    345.20271    345.20271    24192.445    24192.445    155.06838    155.06838 
Loop time of 104.594 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.054 hours/ns, 9.561 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.08     | 104.08     | 104.08     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098348   | 0.098348   | 0.098348   |   0.0 |  0.09
Output  | 0.00019049 | 0.00019049 | 0.00019049 |   0.0 |  0.00
Modify  | 0.35028    | 0.35028    | 0.35028    |   0.0 |  0.33
Other   |            | 0.0601     |            |       |  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:      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 = 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   -8023.8531   -8023.8531   -8113.0504   -8113.0504    345.20271    345.20271    24192.445    24192.445    155.06838    155.06838 
    3000   -8025.8952   -8025.8952   -8111.9021   -8111.9021    332.85533    332.85533    24212.878    24212.878   -1420.6485   -1420.6485 
Loop time of 105.747 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.374 hours/ns, 9.457 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    | 105.23     | 105.23     | 105.23     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098448   | 0.098448   | 0.098448   |   0.0 |  0.09
Output  | 0.0001909  | 0.0001909  | 0.0001909  |   0.0 |  0.00
Modify  | 0.35428    | 0.35428    | 0.35428    |   0.0 |  0.34
Other   |            | 0.06138    |            |       |  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 = 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   -8025.8952   -8025.8952   -8111.9021   -8111.9021    332.85533    332.85533    24212.878    24212.878   -1420.6485   -1420.6485 
    4000   -8022.7041   -8022.7041   -8112.6078   -8112.6078     347.9366     347.9366     24226.14     24226.14   -2685.5718   -2685.5718 
Loop time of 105.161 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.211 hours/ns, 9.509 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.65     | 104.65     | 104.65     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098032   | 0.098032   | 0.098032   |   0.0 |  0.09
Output  | 0.00019069 | 0.00019069 | 0.00019069 |   0.0 |  0.00
Modify  | 0.35195    | 0.35195    | 0.35195    |   0.0 |  0.33
Other   |            | 0.06121    |            |       |  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:      127916.0 ave      127916 max      127916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127916
Ave neighs/atom = 63.958000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -8022.7041   -8022.7041   -8112.6078   -8112.6078     347.9366     347.9366     24226.14     24226.14   -2685.5718   -2685.5718 
    5000   -8027.2273   -8027.2273   -8110.5049   -8110.5049    322.29281    322.29281    24208.564    24208.564   -861.00408   -861.00408 
Loop time of 105.451 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.292 hours/ns, 9.483 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.94     | 104.94     | 104.94     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098663   | 0.098663   | 0.098663   |   0.0 |  0.09
Output  | 0.00015534 | 0.00015534 | 0.00015534 |   0.0 |  0.00
Modify  | 0.35259    | 0.35259    | 0.35259    |   0.0 |  0.33
Other   |            | 0.06071    |            |       |  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:      127906.0 ave      127906 max      127906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127906
Ave neighs/atom = 63.953000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 330.859381788118, Press = -333.406350917435
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   -8027.2273   -8027.2273   -8110.5049   -8110.5049    322.29281    322.29281    24208.564    24208.564   -861.00408   -861.00408 
    6000    -8023.515    -8023.515   -8109.6508   -8109.6508    333.35444    333.35444    24204.848    24204.848    -547.0322    -547.0322 
Loop time of 106.213 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.503 hours/ns, 9.415 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    | 105.68     | 105.68     | 105.68     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098974   | 0.098974   | 0.098974   |   0.0 |  0.09
Output  | 0.00017289 | 0.00017289 | 0.00017289 |   0.0 |  0.00
Modify  | 0.376      | 0.376      | 0.376      |   0.0 |  0.35
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:      127916.0 ave      127916 max      127916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127916
Ave neighs/atom = 63.958000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.577522529194, Press = -50.1641428869202
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    -8023.515    -8023.515   -8109.6508   -8109.6508    333.35444    333.35444    24204.848    24204.848    -547.0322    -547.0322 
    7000   -8026.0012   -8026.0012   -8109.2693   -8109.2693    322.25629    322.25629    24168.219    24168.219    2302.8022    2302.8022 
Loop time of 106.62 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.617 hours/ns, 9.379 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    | 106.08     | 106.08     | 106.08     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099411   | 0.099411   | 0.099411   |   0.0 |  0.09
Output  | 0.00021964 | 0.00021964 | 0.00021964 |   0.0 |  0.00
Modify  | 0.37574    | 0.37574    | 0.37574    |   0.0 |  0.35
Other   |            | 0.06149    |            |       |  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:      127896.0 ave      127896 max      127896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127896
Ave neighs/atom = 63.948000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.19105403293, Press = -30.3389961369515
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   -8026.0012   -8026.0012   -8109.2693   -8109.2693    322.25629    322.25629    24168.219    24168.219    2302.8022    2302.8022 
    8000   -8017.5728   -8017.5728   -8109.5234   -8109.5234    355.85836    355.85836    24153.251    24153.251    3914.2509    3914.2509 
Loop time of 106.528 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.591 hours/ns, 9.387 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    | 105.99     | 105.99     | 105.99     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099029   | 0.099029   | 0.099029   |   0.0 |  0.09
Output  | 0.00015375 | 0.00015375 | 0.00015375 |   0.0 |  0.00
Modify  | 0.37562    | 0.37562    | 0.37562    |   0.0 |  0.35
Other   |            | 0.06113    |            |       |  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 = 333.237305758486, Press = -2.80534747620971
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   -8017.5728   -8017.5728   -8109.5234   -8109.5234    355.85836    355.85836    24153.251    24153.251    3914.2509    3914.2509 
    9000   -8026.1744   -8026.1744   -8112.2072   -8112.2072    332.95586    332.95586    24153.571    24153.571    3112.2316    3112.2316 
Loop time of 106.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.685 hours/ns, 9.357 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    | 106.33     | 106.33     | 106.33     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1001     | 0.1001     | 0.1001     |   0.0 |  0.09
Output  | 0.0001537  | 0.0001537  | 0.0001537  |   0.0 |  0.00
Modify  | 0.37871    | 0.37871    | 0.37871    |   0.0 |  0.35
Other   |            | 0.06169    |            |       |  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:      127912.0 ave      127912 max      127912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127912
Ave neighs/atom = 63.956000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.900548507892, Press = 11.6080198255184
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   -8026.1744   -8026.1744   -8112.2072   -8112.2072    332.95586    332.95586    24153.571    24153.571    3112.2316    3112.2316 
   10000   -8021.8909   -8021.8909   -8112.1382   -8112.1382    349.26643    349.26643    24198.793    24198.793   -317.25222   -317.25222 
Loop time of 106.835 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.676 hours/ns, 9.360 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    | 106.3      | 106.3      | 106.3      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10029    | 0.10029    | 0.10029    |   0.0 |  0.09
Output  | 0.00015354 | 0.00015354 | 0.00015354 |   0.0 |  0.00
Modify  | 0.37717    | 0.37717    | 0.37717    |   0.0 |  0.35
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:        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:      127932.0 ave      127932 max      127932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127932
Ave neighs/atom = 63.966000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.145390699968, Press = 7.50449098189249
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   -8021.8909   -8021.8909   -8112.1382   -8112.1382    349.26643    349.26643    24198.793    24198.793   -317.25222   -317.25222 
   11000   -8026.4516   -8026.4516    -8111.424    -8111.424    328.85202    328.85202     24195.65     24195.65   -110.82666   -110.82666 
Loop time of 106.757 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.655 hours/ns, 9.367 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    | 106.22     | 106.22     | 106.22     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099101   | 0.099101   | 0.099101   |   0.0 |  0.09
Output  | 0.00019366 | 0.00019366 | 0.00019366 |   0.0 |  0.00
Modify  | 0.37727    | 0.37727    | 0.37727    |   0.0 |  0.35
Other   |            | 0.06187    |            |       |  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:      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 = 334.12270410452, Press = 2.96852169705076
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   -8026.4516   -8026.4516    -8111.424    -8111.424    328.85202    328.85202     24195.65     24195.65   -110.82666   -110.82666 
   12000   -8024.5163   -8024.5163    -8113.208    -8113.208    343.24615    343.24615    24221.313    24221.313   -2499.5471   -2499.5471 
Loop time of 106.494 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.582 hours/ns, 9.390 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    | 105.95     | 105.95     | 105.95     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099613   | 0.099613   | 0.099613   |   0.0 |  0.09
Output  | 0.000162   | 0.000162   | 0.000162   |   0.0 |  0.00
Modify  | 0.37844    | 0.37844    | 0.37844    |   0.0 |  0.36
Other   |            | 0.06142    |            |       |  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:      127894.0 ave      127894 max      127894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127894
Ave neighs/atom = 63.947000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.209338772711, Press = 0.241065038167798
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   -8024.5163   -8024.5163    -8113.208    -8113.208    343.24615    343.24615    24221.313    24221.313   -2499.5471   -2499.5471 
   13000   -8022.9404   -8022.9404   -8107.0277   -8107.0277    325.42647    325.42647     24232.17     24232.17   -2222.1694   -2222.1694 
Loop time of 104.936 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.149 hours/ns, 9.530 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.41     | 104.41     | 104.41     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098407   | 0.098407   | 0.098407   |   0.0 |  0.09
Output  | 0.00015634 | 0.00015634 | 0.00015634 |   0.0 |  0.00
Modify  | 0.36835    | 0.36835    | 0.36835    |   0.0 |  0.35
Other   |            | 0.06054    |            |       |  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:      127888.0 ave      127888 max      127888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127888
Ave neighs/atom = 63.944000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.190976693264, Press = -4.9663672491059
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   -8022.9404   -8022.9404   -8107.0277   -8107.0277    325.42647    325.42647     24232.17     24232.17   -2222.1694   -2222.1694 
   14000   -8025.0507   -8025.0507   -8112.6901   -8112.6901    339.17371    339.17371    24217.379    24217.379   -1940.4531   -1940.4531 
Loop time of 106.615 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.615 hours/ns, 9.380 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    | 106.07     | 106.07     | 106.07     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10039    | 0.10039    | 0.10039    |   0.0 |  0.09
Output  | 0.00019992 | 0.00019992 | 0.00019992 |   0.0 |  0.00
Modify  | 0.38124    | 0.38124    | 0.38124    |   0.0 |  0.36
Other   |            | 0.0616     |            |       |  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:      127886.0 ave      127886 max      127886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127886
Ave neighs/atom = 63.943000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.417436752288, Press = -11.4081474852421
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   -8025.0507   -8025.0507   -8112.6901   -8112.6901    339.17371    339.17371    24217.379    24217.379   -1940.4531   -1940.4531 
   15000   -8023.7312   -8023.7312   -8109.1603   -8109.1603    330.61944    330.61944    24189.064    24189.064    871.34526    871.34526 
Loop time of 107.994 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.800 ns/day, 29.998 hours/ns, 9.260 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.45     | 107.45     | 107.45     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1003     | 0.1003     | 0.1003     |   0.0 |  0.09
Output  | 0.00015472 | 0.00015472 | 0.00015472 |   0.0 |  0.00
Modify  | 0.38596    | 0.38596    | 0.38596    |   0.0 |  0.36
Other   |            | 0.06164    |            |       |  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 = 334.451552939034, Press = -7.27128012638336
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   -8023.7312   -8023.7312   -8109.1603   -8109.1603    330.61944    330.61944    24189.064    24189.064    871.34526    871.34526 
   16000   -8023.5542   -8023.5542   -8111.6246   -8111.6246    340.84152    340.84152    24186.259    24186.259     788.0299     788.0299 
Loop time of 105.395 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.277 hours/ns, 9.488 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.87     | 104.87     | 104.87     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09851    | 0.09851    | 0.09851    |   0.0 |  0.09
Output  | 0.00015821 | 0.00015821 | 0.00015821 |   0.0 |  0.00
Modify  | 0.37077    | 0.37077    | 0.37077    |   0.0 |  0.35
Other   |            | 0.06023    |            |       |  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:      127894.0 ave      127894 max      127894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127894
Ave neighs/atom = 63.947000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.584567893966, Press = -0.78175205648345
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   -8023.5542   -8023.5542   -8111.6246   -8111.6246    340.84152    340.84152    24186.259    24186.259     788.0299     788.0299 
   17000    -8024.992    -8024.992   -8109.5876   -8109.5876    327.39405    327.39405    24188.158    24188.158    968.16926    968.16926 
Loop time of 107.946 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.800 ns/day, 29.985 hours/ns, 9.264 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.4      | 107.4      | 107.4      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10106    | 0.10106    | 0.10106    |   0.0 |  0.09
Output  | 0.00015507 | 0.00015507 | 0.00015507 |   0.0 |  0.00
Modify  | 0.38541    | 0.38541    | 0.38541    |   0.0 |  0.36
Other   |            | 0.06173    |            |       |  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:      127898.0 ave      127898 max      127898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127898
Ave neighs/atom = 63.949000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.577205974991, Press = -0.762584871992153
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    -8024.992    -8024.992   -8109.5876   -8109.5876    327.39405    327.39405    24188.158    24188.158    968.16926    968.16926 
   18000   -8025.3251   -8025.3251   -8111.2573   -8111.2573    332.56641    332.56641    24187.855    24187.855    641.84902    641.84902 
Loop time of 105.901 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.417 hours/ns, 9.443 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    | 105.36     | 105.36     | 105.36     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099479   | 0.099479   | 0.099479   |   0.0 |  0.09
Output  | 0.0001557  | 0.0001557  | 0.0001557  |   0.0 |  0.00
Modify  | 0.37577    | 0.37577    | 0.37577    |   0.0 |  0.35
Other   |            | 0.06115    |            |       |  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:      127892.0 ave      127892 max      127892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127892
Ave neighs/atom = 63.946000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.450945210692, Press = 0.207907570661176
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   -8025.3251   -8025.3251   -8111.2573   -8111.2573    332.56641    332.56641    24187.855    24187.855    641.84902    641.84902 
   19000   -8023.7846   -8023.7846   -8109.5465   -8109.5465    331.90749    331.90749    24193.946    24193.946    776.14072    776.14072 
Loop time of 106.109 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.475 hours/ns, 9.424 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    | 105.57     | 105.57     | 105.57     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099498   | 0.099498   | 0.099498   |   0.0 |  0.09
Output  | 0.00015296 | 0.00015296 | 0.00015296 |   0.0 |  0.00
Modify  | 0.37513    | 0.37513    | 0.37513    |   0.0 |  0.35
Other   |            | 0.06107    |            |       |  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:      127920.0 ave      127920 max      127920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127920
Ave neighs/atom = 63.960000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.20349713098, Press = 2.33041720318458
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   -8023.7846   -8023.7846   -8109.5465   -8109.5465    331.90749    331.90749    24193.946    24193.946    776.14072    776.14072 
   20000    -8025.388    -8025.388    -8109.111    -8109.111    324.01682    324.01682    24224.861    24224.861   -2079.1231   -2079.1231 
Loop time of 107.165 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.806 ns/day, 29.768 hours/ns, 9.331 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    | 106.62     | 106.62     | 106.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10133    | 0.10133    | 0.10133    |   0.0 |  0.09
Output  | 0.00021759 | 0.00021759 | 0.00021759 |   0.0 |  0.00
Modify  | 0.37946    | 0.37946    | 0.37946    |   0.0 |  0.35
Other   |            | 0.06128    |            |       |  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:      127906.0 ave      127906 max      127906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127906
Ave neighs/atom = 63.953000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.166607664133, Press = 3.14448631730428
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    -8025.388    -8025.388    -8109.111    -8109.111    324.01682    324.01682    24224.861    24224.861   -2079.1231   -2079.1231 
   21000   -8021.2989   -8021.2989   -8107.5381   -8107.5381    333.75463    333.75463    24249.723    24249.723   -3268.3649   -3268.3649 
Loop time of 106.14 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.483 hours/ns, 9.422 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    | 105.6      | 105.6      | 105.6      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099349   | 0.099349   | 0.099349   |   0.0 |  0.09
Output  | 0.00015264 | 0.00015264 | 0.00015264 |   0.0 |  0.00
Modify  | 0.37682    | 0.37682    | 0.37682    |   0.0 |  0.36
Other   |            | 0.06102    |            |       |  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:      127898.0 ave      127898 max      127898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127898
Ave neighs/atom = 63.949000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.236371237357, Press = -1.62130915021882
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   -8021.2989   -8021.2989   -8107.5381   -8107.5381    333.75463    333.75463    24249.723    24249.723   -3268.3649   -3268.3649 
   22000   -8026.0348   -8026.0348   -8110.7972   -8110.7972    328.03925    328.03925    24209.512    24209.512      -780.45      -780.45 
Loop time of 105.929 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.425 hours/ns, 9.440 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    | 105.4      | 105.4      | 105.4      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09866    | 0.09866    | 0.09866    |   0.0 |  0.09
Output  | 0.00021891 | 0.00021891 | 0.00021891 |   0.0 |  0.00
Modify  | 0.37326    | 0.37326    | 0.37326    |   0.0 |  0.35
Other   |            | 0.06086    |            |       |  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:      127900.0 ave      127900 max      127900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127900
Ave neighs/atom = 63.950000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.200930184765, Press = -3.23785988136503
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   -8026.0348   -8026.0348   -8110.7972   -8110.7972    328.03925    328.03925    24209.512    24209.512      -780.45      -780.45 
   23000    -8023.272    -8023.272    -8110.741    -8110.741     338.5139     338.5139    24191.069    24191.069    446.89096    446.89096 
Loop time of 103.771 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.825 hours/ns, 9.637 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    | 103.25     | 103.25     | 103.25     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097854   | 0.097854   | 0.097854   |   0.0 |  0.09
Output  | 0.00014973 | 0.00014973 | 0.00014973 |   0.0 |  0.00
Modify  | 0.36519    | 0.36519    | 0.36519    |   0.0 |  0.35
Other   |            | 0.05998    |            |       |  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:      127886.0 ave      127886 max      127886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127886
Ave neighs/atom = 63.943000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.271758593535, Press = -2.12194810685638
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    -8023.272    -8023.272    -8110.741    -8110.741     338.5139     338.5139    24191.069    24191.069    446.89096    446.89096 
   24000   -8028.9127   -8028.9127   -8112.5157   -8112.5157    323.55213    323.55213    24179.909    24179.909    952.64906    952.64906 
Loop time of 105.831 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.397 hours/ns, 9.449 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    | 105.3      | 105.3      | 105.3      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098782   | 0.098782   | 0.098782   |   0.0 |  0.09
Output  | 0.00015802 | 0.00015802 | 0.00015802 |   0.0 |  0.00
Modify  | 0.37355    | 0.37355    | 0.37355    |   0.0 |  0.35
Other   |            | 0.06113    |            |       |  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 = 334.159339482996, Press = 0.134574335122571
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.9127   -8028.9127   -8112.5157   -8112.5157    323.55213    323.55213    24179.909    24179.909    952.64906    952.64906 
   25000   -8024.0596   -8024.0596   -8110.2314   -8110.2314    333.49397    333.49397    24201.508    24201.508   -121.39885   -121.39885 
Loop time of 104.311 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.975 hours/ns, 9.587 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    | 103.79     | 103.79     | 103.79     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098115   | 0.098115   | 0.098115   |   0.0 |  0.09
Output  | 0.00015588 | 0.00015588 | 0.00015588 |   0.0 |  0.00
Modify  | 0.3667     | 0.3667     | 0.3667     |   0.0 |  0.35
Other   |            | 0.06057    |            |       |  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:      127904.0 ave      127904 max      127904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127904
Ave neighs/atom = 63.952000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.016075647757, Press = -1.09480794884138
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   -8024.0596   -8024.0596   -8110.2314   -8110.2314    333.49397    333.49397    24201.508    24201.508   -121.39885   -121.39885 
   26000   -8025.5011   -8025.5011   -8112.1481   -8112.1481      335.333      335.333    24196.857    24196.857   -265.47417   -265.47417 
Loop time of 106.341 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.539 hours/ns, 9.404 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    | 105.8      | 105.8      | 105.8      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099618   | 0.099618   | 0.099618   |   0.0 |  0.09
Output  | 0.00020286 | 0.00020286 | 0.00020286 |   0.0 |  0.00
Modify  | 0.37572    | 0.37572    | 0.37572    |   0.0 |  0.35
Other   |            | 0.06136    |            |       |  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:      127890.0 ave      127890 max      127890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127890
Ave neighs/atom = 63.945000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.964229599925, Press = -1.08526886362429
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   -8025.5011   -8025.5011   -8112.1481   -8112.1481      335.333      335.333    24196.857    24196.857   -265.47417   -265.47417 
   27000   -8019.5775   -8019.5775   -8106.8991   -8106.8991    337.94327    337.94327    24197.974    24197.974    600.60417    600.60417 
Loop time of 106.073 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.465 hours/ns, 9.427 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    | 105.54     | 105.54     | 105.54     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099001   | 0.099001   | 0.099001   |   0.0 |  0.09
Output  | 0.0001547  | 0.0001547  | 0.0001547  |   0.0 |  0.00
Modify  | 0.3724     | 0.3724     | 0.3724     |   0.0 |  0.35
Other   |            | 0.06134    |            |       |  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:      127916.0 ave      127916 max      127916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127916
Ave neighs/atom = 63.958000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.025387636376, Press = -1.19550887495718
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   -8019.5775   -8019.5775   -8106.8991   -8106.8991    337.94327    337.94327    24197.974    24197.974    600.60417    600.60417 
   28000   -8025.8089   -8025.8089   -8109.6043   -8109.6043    324.29666    324.29666    24165.416    24165.416    2519.5963    2519.5963 
Loop time of 106.794 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.665 hours/ns, 9.364 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    | 106.25     | 106.25     | 106.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099688   | 0.099688   | 0.099688   |   0.0 |  0.09
Output  | 0.00015279 | 0.00015279 | 0.00015279 |   0.0 |  0.00
Modify  | 0.37818    | 0.37818    | 0.37818    |   0.0 |  0.35
Other   |            | 0.06138    |            |       |  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:      127908.0 ave      127908 max      127908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127908
Ave neighs/atom = 63.954000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.062364469766, Press = 0.555247250897152
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   -8025.8089   -8025.8089   -8109.6043   -8109.6043    324.29666    324.29666    24165.416    24165.416    2519.5963    2519.5963 
   29000   -8021.4309   -8021.4309    -8107.416    -8107.416    332.77113    332.77113    24186.915    24186.915    1545.2464    1545.2464 
Loop time of 106.668 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.630 hours/ns, 9.375 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    | 106.13     | 106.13     | 106.13     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099762   | 0.099762   | 0.099762   |   0.0 |  0.09
Output  | 0.00015314 | 0.00015314 | 0.00015314 |   0.0 |  0.00
Modify  | 0.37697    | 0.37697    | 0.37697    |   0.0 |  0.35
Other   |            | 0.06147    |            |       |  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:      127910.0 ave      127910 max      127910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127910
Ave neighs/atom = 63.955000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.14492607979, Press = 1.59160629987816
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   -8021.4309   -8021.4309    -8107.416    -8107.416    332.77113    332.77113    24186.915    24186.915    1545.2464    1545.2464 
   30000   -8023.8513   -8023.8513   -8111.1682   -8111.1682    337.92548    337.92548    24208.455    24208.455   -957.10432   -957.10432 
Loop time of 106.278 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.522 hours/ns, 9.409 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    | 105.74     | 105.74     | 105.74     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1005     | 0.1005     | 0.1005     |   0.0 |  0.09
Output  | 0.0004051  | 0.0004051  | 0.0004051  |   0.0 |  0.00
Modify  | 0.37736    | 0.37736    | 0.37736    |   0.0 |  0.36
Other   |            | 0.0615     |            |       |  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:      127886.0 ave      127886 max      127886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127886
Ave neighs/atom = 63.943000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.083309993165, Press = 2.44775569160216
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   -8023.8513   -8023.8513   -8111.1682   -8111.1682    337.92548    337.92548    24208.455    24208.455   -957.10432   -957.10432 
   31000   -8028.8706   -8028.8706   -8112.3916   -8112.3916    323.23504    323.23504    24226.718    24226.718   -2912.1371   -2912.1371 
Loop time of 105.658 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.349 hours/ns, 9.464 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    | 105.13     | 105.13     | 105.13     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099675   | 0.099675   | 0.099675   |   0.0 |  0.09
Output  | 0.00015114 | 0.00015114 | 0.00015114 |   0.0 |  0.00
Modify  | 0.37225    | 0.37225    | 0.37225    |   0.0 |  0.35
Other   |            | 0.06073    |            |       |  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:      127920.0 ave      127920 max      127920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127920
Ave neighs/atom = 63.960000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.007270493699, Press = 0.908729613145954
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.8706   -8028.8706   -8112.3916   -8112.3916    323.23504    323.23504    24226.718    24226.718   -2912.1371   -2912.1371 
   32000   -8024.0097   -8024.0097   -8109.7044   -8109.7044    331.64765    331.64765    24219.982    24219.982   -1550.7051   -1550.7051 
Loop time of 104.836 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.121 hours/ns, 9.539 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.3      | 104.3      | 104.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098876   | 0.098876   | 0.098876   |   0.0 |  0.09
Output  | 0.00015489 | 0.00015489 | 0.00015489 |   0.0 |  0.00
Modify  | 0.3721     | 0.3721     | 0.3721     |   0.0 |  0.35
Other   |            | 0.06078    |            |       |  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:      127884.0 ave      127884 max      127884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127884
Ave neighs/atom = 63.942000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.893426534879, Press = -1.0674435272745
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   -8024.0097   -8024.0097   -8109.7044   -8109.7044    331.64765    331.64765    24219.982    24219.982   -1550.7051   -1550.7051 
   33000   -8029.0387   -8029.0387   -8113.3441   -8113.3441    326.27063    326.27063     24192.44     24192.44   -325.44119   -325.44119 
Loop time of 105.241 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.234 hours/ns, 9.502 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.71     | 104.71     | 104.71     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099522   | 0.099522   | 0.099522   |   0.0 |  0.09
Output  | 0.00016518 | 0.00016518 | 0.00016518 |   0.0 |  0.00
Modify  | 0.37261    | 0.37261    | 0.37261    |   0.0 |  0.35
Other   |            | 0.06068    |            |       |  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:      127882.0 ave      127882 max      127882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127882
Ave neighs/atom = 63.941000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.82888616031, Press = -1.84803992201831
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   -8029.0387   -8029.0387   -8113.3441   -8113.3441    326.27063    326.27063     24192.44     24192.44   -325.44119   -325.44119 
   34000   -8023.9349   -8023.9349   -8108.2634   -8108.2634    326.36007    326.36007    24192.398    24192.398    828.33732    828.33732 
Loop time of 104.885 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.135 hours/ns, 9.534 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.36     | 104.36     | 104.36     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097587   | 0.097587   | 0.097587   |   0.0 |  0.09
Output  | 0.00015557 | 0.00015557 | 0.00015557 |   0.0 |  0.00
Modify  | 0.36761    | 0.36761    | 0.36761    |   0.0 |  0.35
Other   |            | 0.06028    |            |       |  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:      127932.0 ave      127932 max      127932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127932
Ave neighs/atom = 63.966000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.727127911676, Press = -1.24366606462636
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   -8023.9349   -8023.9349   -8108.2634   -8108.2634    326.36007    326.36007    24192.398    24192.398    828.33732    828.33732 
   35000   -8027.6649   -8027.6649   -8111.9673   -8111.9673    326.25924    326.25924    24180.934    24180.934    1049.2251    1049.2251 
Loop time of 105.342 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.262 hours/ns, 9.493 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.81     | 104.81     | 104.81     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098777   | 0.098777   | 0.098777   |   0.0 |  0.09
Output  | 0.00015415 | 0.00015415 | 0.00015415 |   0.0 |  0.00
Modify  | 0.36947    | 0.36947    | 0.36947    |   0.0 |  0.35
Other   |            | 0.06038    |            |       |  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:      127918.0 ave      127918 max      127918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127918
Ave neighs/atom = 63.959000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.636533347515, Press = -1.1608987319087
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   -8027.6649   -8027.6649   -8111.9673   -8111.9673    326.25924    326.25924    24180.934    24180.934    1049.2251    1049.2251 
   36000   -8024.6143   -8024.6143   -8110.5511   -8110.5511    332.58426    332.58426    24170.728    24170.728     2029.542     2029.542 
Loop time of 105.578 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.327 hours/ns, 9.472 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    | 105.05     | 105.05     | 105.05     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097901   | 0.097901   | 0.097901   |   0.0 |  0.09
Output  | 0.00015583 | 0.00015583 | 0.00015583 |   0.0 |  0.00
Modify  | 0.37346    | 0.37346    | 0.37346    |   0.0 |  0.35
Other   |            | 0.06124    |            |       |  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:      127916.0 ave      127916 max      127916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127916
Ave neighs/atom = 63.958000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.55513347504, Press = -1.07991948795967
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   -8024.6143   -8024.6143   -8110.5511   -8110.5511    332.58426    332.58426    24170.728    24170.728     2029.542     2029.542 
   37000   -8025.8758   -8025.8758   -8112.0859   -8112.0859    333.64177    333.64177    24164.143    24164.143    2298.6505    2298.6505 
Loop time of 106.281 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.523 hours/ns, 9.409 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    | 105.74     | 105.74     | 105.74     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10005    | 0.10005    | 0.10005    |   0.0 |  0.09
Output  | 0.00019634 | 0.00019634 | 0.00019634 |   0.0 |  0.00
Modify  | 0.37726    | 0.37726    | 0.37726    |   0.0 |  0.35
Other   |            | 0.0614     |            |       |  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:      127920.0 ave      127920 max      127920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127920
Ave neighs/atom = 63.960000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.558893942264, Press = 0.647651696857763
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   -8025.8758   -8025.8758   -8112.0859   -8112.0859    333.64177    333.64177    24164.143    24164.143    2298.6505    2298.6505 
   38000     -8024.21     -8024.21   -8110.8537   -8110.8537    335.31979    335.31979    24178.766    24178.766    1507.8789    1507.8789 
Loop time of 105.687 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.358 hours/ns, 9.462 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    | 105.15     | 105.15     | 105.15     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098447   | 0.098447   | 0.098447   |   0.0 |  0.09
Output  | 0.00015619 | 0.00015619 | 0.00015619 |   0.0 |  0.00
Modify  | 0.37273    | 0.37273    | 0.37273    |   0.0 |  0.35
Other   |            | 0.06069    |            |       |  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:      127920.0 ave      127920 max      127920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127920
Ave neighs/atom = 63.960000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.541807319498, Press = 2.60324284873619
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     -8024.21     -8024.21   -8110.8537   -8110.8537    335.31979    335.31979    24178.766    24178.766    1507.8789    1507.8789 
   39000   -8027.9312   -8027.9312    -8112.115    -8112.115    325.79993    325.79993    24201.616    24201.616    -527.6171    -527.6171 
Loop time of 106.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.561 hours/ns, 9.397 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    | 105.88     | 105.88     | 105.88     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099821   | 0.099821   | 0.099821   |   0.0 |  0.09
Output  | 0.00015301 | 0.00015301 | 0.00015301 |   0.0 |  0.00
Modify  | 0.37721    | 0.37721    | 0.37721    |   0.0 |  0.35
Other   |            | 0.06132    |            |       |  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:      127932.0 ave      127932 max      127932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127932
Ave neighs/atom = 63.966000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.522318592073, Press = 1.00074876176826
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   -8027.9312   -8027.9312    -8112.115    -8112.115    325.79993    325.79993    24201.616    24201.616    -527.6171    -527.6171 
   40000   -8023.8793   -8023.8793   -8109.4879   -8109.4879    331.31418    331.31418    24211.641    24211.641   -763.07406   -763.07406 
Loop time of 106.066 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.463 hours/ns, 9.428 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    | 105.53     | 105.53     | 105.53     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099468   | 0.099468   | 0.099468   |   0.0 |  0.09
Output  | 0.00015348 | 0.00015348 | 0.00015348 |   0.0 |  0.00
Modify  | 0.37743    | 0.37743    | 0.37743    |   0.0 |  0.36
Other   |            | 0.06141    |            |       |  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 = 333.444650949443, Press = -0.416420310727317
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   -8023.8793   -8023.8793   -8109.4879   -8109.4879    331.31418    331.31418    24211.641    24211.641   -763.07406   -763.07406 
   41000   -8028.2357   -8028.2357   -8110.3909   -8110.3909      317.949      317.949     24198.94     24198.94   -337.63028   -337.63028 
Loop time of 106.144 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.484 hours/ns, 9.421 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.61     | 105.61     | 105.61     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0995     | 0.0995     | 0.0995     |   0.0 |  0.09
Output  | 0.00015293 | 0.00015293 | 0.00015293 |   0.0 |  0.00
Modify  | 0.37264    | 0.37264    | 0.37264    |   0.0 |  0.35
Other   |            | 0.06097    |            |       |  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:      127912.0 ave      127912 max      127912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127912
Ave neighs/atom = 63.956000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.36203570362, Press = -0.728207208179257
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   -8028.2357   -8028.2357   -8110.3909   -8110.3909      317.949      317.949     24198.94     24198.94   -337.63028   -337.63028 
   42000   -8024.3157   -8024.3157   -8108.2458   -8108.2458    324.81784    324.81784    24198.184    24198.184    346.26761    346.26761 
Loop time of 105.245 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.235 hours/ns, 9.502 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.71     | 104.71     | 104.71     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098916   | 0.098916   | 0.098916   |   0.0 |  0.09
Output  | 0.0001532  | 0.0001532  | 0.0001532  |   0.0 |  0.00
Modify  | 0.37177    | 0.37177    | 0.37177    |   0.0 |  0.35
Other   |            | 0.0609     |            |       |  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:      127898.0 ave      127898 max      127898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127898
Ave neighs/atom = 63.949000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.348653106683, Press = -1.10860982526182
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   -8024.3157   -8024.3157   -8108.2458   -8108.2458    324.81784    324.81784    24198.184    24198.184    346.26761    346.26761 
   43000   -8024.0633   -8024.0633   -8111.3687   -8111.3687    337.88085    337.88085    24208.216    24208.216   -823.45521   -823.45521 
Loop time of 105.311 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.253 hours/ns, 9.496 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.78     | 104.78     | 104.78     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098821   | 0.098821   | 0.098821   |   0.0 |  0.09
Output  | 0.00015344 | 0.00015344 | 0.00015344 |   0.0 |  0.00
Modify  | 0.37533    | 0.37533    | 0.37533    |   0.0 |  0.36
Other   |            | 0.06098    |            |       |  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:      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 = 333.316641447439, Press = -1.32372212785949
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   -8024.0633   -8024.0633   -8111.3687   -8111.3687    337.88085    337.88085    24208.216    24208.216   -823.45521   -823.45521 
   44000   -8028.6647   -8028.6647   -8113.2111   -8113.2111    327.20339    327.20339    24189.331    24189.331    201.06428    201.06428 
Loop time of 106.873 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.687 hours/ns, 9.357 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    | 106.33     | 106.33     | 106.33     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099298   | 0.099298   | 0.099298   |   0.0 |  0.09
Output  | 0.00015323 | 0.00015323 | 0.00015323 |   0.0 |  0.00
Modify  | 0.37982    | 0.37982    | 0.37982    |   0.0 |  0.36
Other   |            | 0.06186    |            |       |  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:      127932.0 ave      127932 max      127932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127932
Ave neighs/atom = 63.966000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.276166920231, Press = -1.76636058750928
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   -8028.6647   -8028.6647   -8113.2111   -8113.2111    327.20339    327.20339    24189.331    24189.331    201.06428    201.06428 
   45000   -8023.5593   -8023.5593   -8111.0109   -8111.0109    338.44683    338.44683    24172.219    24172.219    1997.2518    1997.2518 
Loop time of 105.838 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.399 hours/ns, 9.448 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    | 105.3      | 105.3      | 105.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097987   | 0.097987   | 0.097987   |   0.0 |  0.09
Output  | 0.00015237 | 0.00015237 | 0.00015237 |   0.0 |  0.00
Modify  | 0.37516    | 0.37516    | 0.37516    |   0.0 |  0.35
Other   |            | 0.06156    |            |       |  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 = 333.221819403808, Press = -1.66532545015646
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   -8023.5593   -8023.5593   -8111.0109   -8111.0109    338.44683    338.44683    24172.219    24172.219    1997.2518    1997.2518 
   46000   -8026.1058   -8026.1058   -8111.8297   -8111.8297    331.76017    331.76017    24145.758    24145.758    3903.8931    3903.8931 
Loop time of 104.897 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.138 hours/ns, 9.533 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.37     | 104.37     | 104.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098569   | 0.098569   | 0.098569   |   0.0 |  0.09
Output  | 0.00015316 | 0.00015316 | 0.00015316 |   0.0 |  0.00
Modify  | 0.37139    | 0.37139    | 0.37139    |   0.0 |  0.35
Other   |            | 0.06065    |            |       |  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 = 333.182338370608, Press = -0.669173148657342
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   -8026.1058   -8026.1058   -8111.8297   -8111.8297    331.76017    331.76017    24145.758    24145.758    3903.8931    3903.8931 
   47000   -8022.2977   -8022.2977   -8110.9807   -8110.9807    343.21237    343.21237    24169.638    24169.638    2136.0804    2136.0804 
Loop time of 104.745 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.096 hours/ns, 9.547 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.22     | 104.22     | 104.22     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098071   | 0.098071   | 0.098071   |   0.0 |  0.09
Output  | 0.00015566 | 0.00015566 | 0.00015566 |   0.0 |  0.00
Modify  | 0.36967    | 0.36967    | 0.36967    |   0.0 |  0.35
Other   |            | 0.06065    |            |       |  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 = 333.19683877478, Press = 0.857045081969329
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   -8022.2977   -8022.2977   -8110.9807   -8110.9807    343.21237    343.21237    24169.638    24169.638    2136.0804    2136.0804 
   48000   -8023.1893   -8023.1893   -8109.4635   -8109.4635    333.89003    333.89003    24197.252    24197.252    334.42337    334.42337 
Loop time of 107.185 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.806 ns/day, 29.774 hours/ns, 9.330 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    | 106.64     | 106.64     | 106.64     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10013    | 0.10013    | 0.10013    |   0.0 |  0.09
Output  | 0.00015586 | 0.00015586 | 0.00015586 |   0.0 |  0.00
Modify  | 0.3806     | 0.3806     | 0.3806     |   0.0 |  0.36
Other   |            | 0.06171    |            |       |  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:      127932.0 ave      127932 max      127932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127932
Ave neighs/atom = 63.966000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.199373912259, Press = 0.246163919245705
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   -8023.1893   -8023.1893   -8109.4635   -8109.4635    333.89003    333.89003    24197.252    24197.252    334.42337    334.42337 
   49000   -8021.5723   -8021.5723   -8108.0737   -8108.0737     334.7693     334.7693    24214.034    24214.034   -702.69835   -702.69835 
Loop time of 105.295 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.249 hours/ns, 9.497 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.76     | 104.76     | 104.76     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098253   | 0.098253   | 0.098253   |   0.0 |  0.09
Output  | 0.00015352 | 0.00015352 | 0.00015352 |   0.0 |  0.00
Modify  | 0.37272    | 0.37272    | 0.37272    |   0.0 |  0.35
Other   |            | 0.06067    |            |       |  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:      127916.0 ave      127916 max      127916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127916
Ave neighs/atom = 63.958000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.187498664882, Press = 0.328273202277055
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   -8021.5723   -8021.5723   -8108.0737   -8108.0737     334.7693     334.7693    24214.034    24214.034   -702.69835   -702.69835 
   50000    -8025.674    -8025.674   -8111.2561   -8111.2561    331.21152    331.21152    24206.925    24206.925    -843.3841    -843.3841 
Loop time of 105.576 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.327 hours/ns, 9.472 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    | 105.04     | 105.04     | 105.04     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098721   | 0.098721   | 0.098721   |   0.0 |  0.09
Output  | 0.00016273 | 0.00016273 | 0.00016273 |   0.0 |  0.00
Modify  | 0.37441    | 0.37441    | 0.37441    |   0.0 |  0.35
Other   |            | 0.06121    |            |       |  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:      127904.0 ave      127904 max      127904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127904
Ave neighs/atom = 63.952000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.235946389567, Press = -0.317889959710168
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    -8025.674    -8025.674   -8111.2561   -8111.2561    331.21152    331.21152    24206.925    24206.925    -843.3841    -843.3841 
   51000    -8019.763    -8019.763    -8108.076    -8108.076    341.78068    341.78068    24214.667    24214.667   -754.20542   -754.20542 
Loop time of 104.82 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.117 hours/ns, 9.540 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.29     | 104.29     | 104.29     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097617   | 0.097617   | 0.097617   |   0.0 |  0.09
Output  | 0.00019939 | 0.00019939 | 0.00019939 |   0.0 |  0.00
Modify  | 0.36956    | 0.36956    | 0.36956    |   0.0 |  0.35
Other   |            | 0.06109    |            |       |  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:      127904.0 ave      127904 max      127904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127904
Ave neighs/atom = 63.952000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.29414474479, Press = -0.961071360646555
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    -8019.763    -8019.763    -8108.076    -8108.076    341.78068    341.78068    24214.667    24214.667   -754.20542   -754.20542 
   52000   -8023.6342   -8023.6342   -8113.2666   -8113.2666     346.8868     346.8868    24214.858    24214.858   -1898.5525   -1898.5525 
Loop time of 103.88 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.855 hours/ns, 9.627 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    | 103.35     | 103.35     | 103.35     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098148   | 0.098148   | 0.098148   |   0.0 |  0.09
Output  | 0.00015134 | 0.00015134 | 0.00015134 |   0.0 |  0.00
Modify  | 0.36722    | 0.36722    | 0.36722    |   0.0 |  0.35
Other   |            | 0.06042    |            |       |  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:      127888.0 ave      127888 max      127888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127888
Ave neighs/atom = 63.944000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.29471740847, Press = -1.61507967548979
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   -8023.6342   -8023.6342   -8113.2666   -8113.2666     346.8868     346.8868    24214.858    24214.858   -1898.5525   -1898.5525 
   53000   -8026.1203   -8026.1203   -8109.8602   -8109.8602    324.08181    324.08181     24197.86     24197.86    -180.9119    -180.9119 
Loop time of 103.992 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.887 hours/ns, 9.616 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    | 103.47     | 103.47     | 103.47     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09711    | 0.09711    | 0.09711    |   0.0 |  0.09
Output  | 0.00016169 | 0.00016169 | 0.00016169 |   0.0 |  0.00
Modify  | 0.36395    | 0.36395    | 0.36395    |   0.0 |  0.35
Other   |            | 0.06017    |            |       |  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:      127904.0 ave      127904 max      127904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127904
Ave neighs/atom = 63.952000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.339780945211, Press = -1.79962406737217
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   -8026.1203   -8026.1203   -8109.8602   -8109.8602    324.08181    324.08181     24197.86     24197.86    -180.9119    -180.9119 
   54000   -8021.1208   -8021.1208   -8107.4164   -8107.4164    333.97286    333.97286    24181.737    24181.737    1687.1818    1687.1818 
Loop time of 103.592 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.776 hours/ns, 9.653 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    | 103.07     | 103.07     | 103.07     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097469   | 0.097469   | 0.097469   |   0.0 |  0.09
Output  | 0.00015435 | 0.00015435 | 0.00015435 |   0.0 |  0.00
Modify  | 0.36492    | 0.36492    | 0.36492    |   0.0 |  0.35
Other   |            | 0.06036    |            |       |  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:      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 = 333.376482896647, Press = -1.87993165279711
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   -8021.1208   -8021.1208   -8107.4164   -8107.4164    333.97286    333.97286    24181.737    24181.737    1687.1818    1687.1818 
   55000   -8023.6677   -8023.6677   -8110.2177   -8110.2177    334.95723    334.95723    24143.042    24143.042    4273.8992    4273.8992 
Loop time of 102.868 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.574 hours/ns, 9.721 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    | 102.35     | 102.35     | 102.35     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096483   | 0.096483   | 0.096483   |   0.0 |  0.09
Output  | 0.00015372 | 0.00015372 | 0.00015372 |   0.0 |  0.00
Modify  | 0.3597     | 0.3597     | 0.3597     |   0.0 |  0.35
Other   |            | 0.06051    |            |       |  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:      127908.0 ave      127908 max      127908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127908
Ave neighs/atom = 63.954000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.369059438436, Press = -0.519163391455044
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   -8023.6677   -8023.6677   -8110.2177   -8110.2177    334.95723    334.95723    24143.042    24143.042    4273.8992    4273.8992 
   56000      -8023.7      -8023.7   -8111.1599   -8111.1599    338.47877    338.47877    24151.852    24151.852    3599.7398    3599.7398 
Loop time of 103.575 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.771 hours/ns, 9.655 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    | 103.05     | 103.05     | 103.05     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096748   | 0.096748   | 0.096748   |   0.0 |  0.09
Output  | 0.00017168 | 0.00017168 | 0.00017168 |   0.0 |  0.00
Modify  | 0.36444    | 0.36444    | 0.36444    |   0.0 |  0.35
Other   |            | 0.06046    |            |       |  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:      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 = 333.352565029754, Press = 0.990016202796976
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      -8023.7      -8023.7   -8111.1599   -8111.1599    338.47877    338.47877    24151.852    24151.852    3599.7398    3599.7398 
   57000   -8026.5916   -8026.5916   -8113.5247   -8113.5247    336.44029    336.44029     24194.14     24194.14   -268.61554   -268.61554 
Loop time of 103.38 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.717 hours/ns, 9.673 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    | 102.86     | 102.86     | 102.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097575   | 0.097575   | 0.097575   |   0.0 |  0.09
Output  | 0.00019162 | 0.00019162 | 0.00019162 |   0.0 |  0.00
Modify  | 0.36361    | 0.36361    | 0.36361    |   0.0 |  0.35
Other   |            | 0.06081    |            |       |  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 = 333.333881001379, Press = 0.277050982283294
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   -8026.5916   -8026.5916   -8113.5247   -8113.5247    336.44029    336.44029     24194.14     24194.14   -268.61554   -268.61554 
   58000   -8024.3183   -8024.3183   -8110.6756   -8110.6756    334.21177    334.21177    24199.763    24199.763   -116.99817   -116.99817 
Loop time of 105.388 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.274 hours/ns, 9.489 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.85     | 104.85     | 104.85     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09894    | 0.09894    | 0.09894    |   0.0 |  0.09
Output  | 0.00015208 | 0.00015208 | 0.00015208 |   0.0 |  0.00
Modify  | 0.37395    | 0.37395    | 0.37395    |   0.0 |  0.35
Other   |            | 0.0608     |            |       |  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:      127934.0 ave      127934 max      127934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127934
Ave neighs/atom = 63.967000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
24197.150457908

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0