# 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.002 seconds

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

kim_interactions Cr

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

kim interactions Cr
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_WuLeeSu_2017_NiCr__MO_880803040302_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_880803040302_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 102.337 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.427 hours/ns, 9.772 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    | 101.83     | 101.83     | 101.83     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098914   | 0.098914   | 0.098914   |   0.0 |  0.10
Output  | 0.0002012  | 0.0002012  | 0.0002012  |   0.0 |  0.00
Modify  | 0.35224    | 0.35224    | 0.35224    |   0.0 |  0.34
Other   |            | 0.06015    |            |       |  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.969 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.158 hours/ns, 9.527 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.46     | 104.46     | 104.46     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098176   | 0.098176   | 0.098176   |   0.0 |  0.09
Output  | 0.00019228 | 0.00019228 | 0.00019228 |   0.0 |  0.00
Modify  | 0.35067    | 0.35067    | 0.35067    |   0.0 |  0.33
Other   |            | 0.05976    |            |       |  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 104.684 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.079 hours/ns, 9.553 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.18     | 104.18     | 104.18     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098442   | 0.098442   | 0.098442   |   0.0 |  0.09
Output  | 0.00019342 | 0.00019342 | 0.00019342 |   0.0 |  0.00
Modify  | 0.34895    | 0.34895    | 0.34895    |   0.0 |  0.33
Other   |            | 0.05903    |            |       |  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 108.181 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.799 ns/day, 30.050 hours/ns, 9.244 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.65     | 107.65     | 107.65     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10128    | 0.10128    | 0.10128    |   0.0 |  0.09
Output  | 0.00019006 | 0.00019006 | 0.00019006 |   0.0 |  0.00
Modify  | 0.36763    | 0.36763    | 0.36763    |   0.0 |  0.34
Other   |            | 0.06144    |            |       |  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 109.057 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.53     | 108.53     | 108.53     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10118    | 0.10118    | 0.10118    |   0.0 |  0.09
Output  | 0.00015384 | 0.00015384 | 0.00015384 |   0.0 |  0.00
Modify  | 0.36938    | 0.36938    | 0.36938    |   0.0 |  0.34
Other   |            | 0.06131    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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 107.727 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.924 hours/ns, 9.283 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.18     | 107.18     | 107.18     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10072    | 0.10072    | 0.10072    |   0.0 |  0.09
Output  | 0.00015744 | 0.00015744 | 0.00015744 |   0.0 |  0.00
Modify  | 0.38073    | 0.38073    | 0.38073    |   0.0 |  0.35
Other   |            | 0.06118    |            |       |  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.538 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.594 hours/ns, 9.386 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        | 106        | 106        |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099531   | 0.099531   | 0.099531   |   0.0 |  0.09
Output  | 0.00015504 | 0.00015504 | 0.00015504 |   0.0 |  0.00
Modify  | 0.37553    | 0.37553    | 0.37553    |   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:        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 107.058 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.738 hours/ns, 9.341 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.52     | 106.52     | 106.52     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10089    | 0.10089    | 0.10089    |   0.0 |  0.09
Output  | 0.00015412 | 0.00015412 | 0.00015412 |   0.0 |  0.00
Modify  | 0.3771     | 0.3771     | 0.3771     |   0.0 |  0.35
Other   |            | 0.06045    |            |       |  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 105.654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.348 hours/ns, 9.465 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.12     | 105.12     | 105.12     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09853    | 0.09853    | 0.09853    |   0.0 |  0.09
Output  | 0.0001543  | 0.0001543  | 0.0001543  |   0.0 |  0.00
Modify  | 0.37217    | 0.37217    | 0.37217    |   0.0 |  0.35
Other   |            | 0.06033    |            |       |  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 107.475 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.854 hours/ns, 9.304 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.93     | 106.93     | 106.93     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10084    | 0.10084    | 0.10084    |   0.0 |  0.09
Output  | 0.00018877 | 0.00018877 | 0.00018877 |   0.0 |  0.00
Modify  | 0.38236    | 0.38236    | 0.38236    |   0.0 |  0.36
Other   |            | 0.06125    |            |       |  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 107.164 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.62     | 106.62     | 106.62     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099991   | 0.099991   | 0.099991   |   0.0 |  0.09
Output  | 0.00015701 | 0.00015701 | 0.00015701 |   0.0 |  0.00
Modify  | 0.37968    | 0.37968    | 0.37968    |   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:      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.826 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.674 hours/ns, 9.361 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.29     | 106.29     | 106.29     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099781   | 0.099781   | 0.099781   |   0.0 |  0.09
Output  | 0.00015682 | 0.00015682 | 0.00015682 |   0.0 |  0.00
Modify  | 0.37675    | 0.37675    | 0.37675    |   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:        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 108.935 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.793 ns/day, 30.260 hours/ns, 9.180 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.39     | 108.39     | 108.39     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10127    | 0.10127    | 0.10127    |   0.0 |  0.09
Output  | 0.000156   | 0.000156   | 0.000156   |   0.0 |  0.00
Modify  | 0.38656    | 0.38656    | 0.38656    |   0.0 |  0.35
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:      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.68 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.633 hours/ns, 9.374 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.15     | 106.15     | 106.15     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10017    | 0.10017    | 0.10017    |   0.0 |  0.09
Output  | 0.00015708 | 0.00015708 | 0.00015708 |   0.0 |  0.00
Modify  | 0.37462    | 0.37462    | 0.37462    |   0.0 |  0.35
Other   |            | 0.05991    |            |       |  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 105.959 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.433 hours/ns, 9.438 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.42     | 105.42     | 105.42     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099988   | 0.099988   | 0.099988   |   0.0 |  0.09
Output  | 0.00015487 | 0.00015487 | 0.00015487 |   0.0 |  0.00
Modify  | 0.37483    | 0.37483    | 0.37483    |   0.0 |  0.35
Other   |            | 0.0605     |            |       |  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 104.415 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.004 hours/ns, 9.577 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.89     | 103.89     | 103.89     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098152   | 0.098152   | 0.098152   |   0.0 |  0.09
Output  | 0.00015554 | 0.00015554 | 0.00015554 |   0.0 |  0.00
Modify  | 0.36506    | 0.36506    | 0.36506    |   0.0 |  0.35
Other   |            | 0.05955    |            |       |  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 108.678 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.795 ns/day, 30.188 hours/ns, 9.201 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.13     | 108.13     | 108.13     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10198    | 0.10198    | 0.10198    |   0.0 |  0.09
Output  | 0.00015543 | 0.00015543 | 0.00015543 |   0.0 |  0.00
Modify  | 0.38732    | 0.38732    | 0.38732    |   0.0 |  0.36
Other   |            | 0.06135    |            |       |  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 107.696 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.915 hours/ns, 9.285 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.15     | 107.15     | 107.15     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10158    | 0.10158    | 0.10158    |   0.0 |  0.09
Output  | 0.00015651 | 0.00015651 | 0.00015651 |   0.0 |  0.00
Modify  | 0.38243    | 0.38243    | 0.38243    |   0.0 |  0.36
Other   |            | 0.06099    |            |       |  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 107.527 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.869 hours/ns, 9.300 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.98     | 106.98     | 106.98     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10119    | 0.10119    | 0.10119    |   0.0 |  0.09
Output  | 0.00020559 | 0.00020559 | 0.00020559 |   0.0 |  0.00
Modify  | 0.38111    | 0.38111    | 0.38111    |   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:        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 106.561 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.600 hours/ns, 9.384 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.02     | 106.02     | 106.02     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099866   | 0.099866   | 0.099866   |   0.0 |  0.09
Output  | 0.00020778 | 0.00020778 | 0.00020778 |   0.0 |  0.00
Modify  | 0.37644    | 0.37644    | 0.37644    |   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:        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 103.939 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.872 hours/ns, 9.621 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.42     | 103.42     | 103.42     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097184   | 0.097184   | 0.097184   |   0.0 |  0.09
Output  | 0.00019239 | 0.00019239 | 0.00019239 |   0.0 |  0.00
Modify  | 0.36451    | 0.36451    | 0.36451    |   0.0 |  0.35
Other   |            | 0.05925    |            |       |  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 107.851 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.801 ns/day, 29.959 hours/ns, 9.272 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.3      | 107.3      | 107.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10155    | 0.10155    | 0.10155    |   0.0 |  0.09
Output  | 0.00015338 | 0.00015338 | 0.00015338 |   0.0 |  0.00
Modify  | 0.38651    | 0.38651    | 0.38651    |   0.0 |  0.36
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:      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 105.998 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.444 hours/ns, 9.434 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.46     | 105.46     | 105.46     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10045    | 0.10045    | 0.10045    |   0.0 |  0.09
Output  | 0.00025611 | 0.00025611 | 0.00025611 |   0.0 |  0.00
Modify  | 0.37414    | 0.37414    | 0.37414    |   0.0 |  0.35
Other   |            | 0.06015    |            |       |  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 106.787 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.663 hours/ns, 9.364 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.25     | 106.25     | 106.25     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10025    | 0.10025    | 0.10025    |   0.0 |  0.09
Output  | 0.00019719 | 0.00019719 | 0.00019719 |   0.0 |  0.00
Modify  | 0.37617    | 0.37617    | 0.37617    |   0.0 |  0.35
Other   |            | 0.06083    |            |       |  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 107.477 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.93     | 106.93     | 106.93     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10045    | 0.10045    | 0.10045    |   0.0 |  0.09
Output  | 0.00019967 | 0.00019967 | 0.00019967 |   0.0 |  0.00
Modify  | 0.38219    | 0.38219    | 0.38219    |   0.0 |  0.36
Other   |            | 0.06056    |            |       |  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 105.225 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.229 hours/ns, 9.503 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.69     | 104.69     | 104.69     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098984   | 0.098984   | 0.098984   |   0.0 |  0.09
Output  | 0.00015637 | 0.00015637 | 0.00015637 |   0.0 |  0.00
Modify  | 0.37281    | 0.37281    | 0.37281    |   0.0 |  0.35
Other   |            | 0.06002    |            |       |  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.198 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.499 hours/ns, 9.416 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.66     | 105.66     | 105.66     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09969    | 0.09969    | 0.09969    |   0.0 |  0.09
Output  | 0.0001552  | 0.0001552  | 0.0001552  |   0.0 |  0.00
Modify  | 0.37591    | 0.37591    | 0.37591    |   0.0 |  0.35
Other   |            | 0.06085    |            |       |  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 104.709 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.086 hours/ns, 9.550 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.18     | 104.18     | 104.18     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098224   | 0.098224   | 0.098224   |   0.0 |  0.09
Output  | 0.00014934 | 0.00014934 | 0.00014934 |   0.0 |  0.00
Modify  | 0.36729    | 0.36729    | 0.36729    |   0.0 |  0.35
Other   |            | 0.05946    |            |       |  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.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.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10103    | 0.10103    | 0.10103    |   0.0 |  0.09
Output  | 0.00015562 | 0.00015562 | 0.00015562 |   0.0 |  0.00
Modify  | 0.37763    | 0.37763    | 0.37763    |   0.0 |  0.35
Other   |            | 0.06041    |            |       |  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 107.247 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.71     | 106.71     | 106.71     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10106    | 0.10106    | 0.10106    |   0.0 |  0.09
Output  | 0.00046096 | 0.00046096 | 0.00046096 |   0.0 |  0.00
Modify  | 0.37836    | 0.37836    | 0.37836    |   0.0 |  0.35
Other   |            | 0.06025    |            |       |  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.242 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.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098848   | 0.098848   | 0.098848   |   0.0 |  0.09
Output  | 0.00019022 | 0.00019022 | 0.00019022 |   0.0 |  0.00
Modify  | 0.37087    | 0.37087    | 0.37087    |   0.0 |  0.35
Other   |            | 0.06056    |            |       |  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 105.614 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.337 hours/ns, 9.468 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.08     | 105.08     | 105.08     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09959    | 0.09959    | 0.09959    |   0.0 |  0.09
Output  | 0.00015466 | 0.00015466 | 0.00015466 |   0.0 |  0.00
Modify  | 0.37567    | 0.37567    | 0.37567    |   0.0 |  0.36
Other   |            | 0.06026    |            |       |  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 107.174 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.63     | 106.63     | 106.63     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10044    | 0.10044    | 0.10044    |   0.0 |  0.09
Output  | 0.00015576 | 0.00015576 | 0.00015576 |   0.0 |  0.00
Modify  | 0.3832     | 0.3832     | 0.3832     |   0.0 |  0.36
Other   |            | 0.06129    |            |       |  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 105.901 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.417 hours/ns, 9.443 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.37     | 105.37     | 105.37     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09964    | 0.09964    | 0.09964    |   0.0 |  0.09
Output  | 0.00015569 | 0.00015569 | 0.00015569 |   0.0 |  0.00
Modify  | 0.37253    | 0.37253    | 0.37253    |   0.0 |  0.35
Other   |            | 0.06013    |            |       |  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.364 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.268 hours/ns, 9.491 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.83     | 104.83     | 104.83     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09981    | 0.09981    | 0.09981    |   0.0 |  0.09
Output  | 0.00015558 | 0.00015558 | 0.00015558 |   0.0 |  0.00
Modify  | 0.36951    | 0.36951    | 0.36951    |   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:      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 110.171 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.784 ns/day, 30.603 hours/ns, 9.077 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    | 109.61     | 109.61     | 109.61     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10321    | 0.10321    | 0.10321    |   0.0 |  0.09
Output  | 0.0001586  | 0.0001586  | 0.0001586  |   0.0 |  0.00
Modify  | 0.39691    | 0.39691    | 0.39691    |   0.0 |  0.36
Other   |            | 0.06211    |            |       |  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.557 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.599 hours/ns, 9.385 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.02     | 106.02     | 106.02     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10032    | 0.10032    | 0.10032    |   0.0 |  0.09
Output  | 0.0002012  | 0.0002012  | 0.0002012  |   0.0 |  0.00
Modify  | 0.37851    | 0.37851    | 0.37851    |   0.0 |  0.36
Other   |            | 0.06087    |            |       |  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 107.025 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.729 hours/ns, 9.344 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.48     | 106.48     | 106.48     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10069    | 0.10069    | 0.10069    |   0.0 |  0.09
Output  | 0.00019952 | 0.00019952 | 0.00019952 |   0.0 |  0.00
Modify  | 0.37935    | 0.37935    | 0.37935    |   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:      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 104.751 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.098 hours/ns, 9.546 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.22     | 104.22     | 104.22     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098134   | 0.098134   | 0.098134   |   0.0 |  0.09
Output  | 0.00015643 | 0.00015643 | 0.00015643 |   0.0 |  0.00
Modify  | 0.36893    | 0.36893    | 0.36893    |   0.0 |  0.35
Other   |            | 0.05995    |            |       |  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 102.549 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.486 hours/ns, 9.751 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.03     | 102.03     | 102.03     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096991   | 0.096991   | 0.096991   |   0.0 |  0.09
Output  | 0.00015702 | 0.00015702 | 0.00015702 |   0.0 |  0.00
Modify  | 0.35809    | 0.35809    | 0.35809    |   0.0 |  0.35
Other   |            | 0.05913    |            |       |  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 108.072 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.799 ns/day, 30.020 hours/ns, 9.253 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.52     | 107.52     | 107.52     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10127    | 0.10127    | 0.10127    |   0.0 |  0.09
Output  | 0.00015587 | 0.00015587 | 0.00015587 |   0.0 |  0.00
Modify  | 0.38705    | 0.38705    | 0.38705    |   0.0 |  0.36
Other   |            | 0.06131    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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.737 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.371 hours/ns, 9.457 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.2      | 105.2      | 105.2      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09978    | 0.09978    | 0.09978    |   0.0 |  0.09
Output  | 0.00015778 | 0.00015778 | 0.00015778 |   0.0 |  0.00
Modify  | 0.37216    | 0.37216    | 0.37216    |   0.0 |  0.35
Other   |            | 0.0602     |            |       |  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 103.253 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.681 hours/ns, 9.685 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    | 102.73     | 102.73     | 102.73     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098192   | 0.098192   | 0.098192   |   0.0 |  0.10
Output  | 0.00021003 | 0.00021003 | 0.00021003 |   0.0 |  0.00
Modify  | 0.36081    | 0.36081    | 0.36081    |   0.0 |  0.35
Other   |            | 0.0595     |            |       |  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 104.586 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.052 hours/ns, 9.562 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.06     | 104.06     | 104.06     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098472   | 0.098472   | 0.098472   |   0.0 |  0.09
Output  | 0.00015504 | 0.00015504 | 0.00015504 |   0.0 |  0.00
Modify  | 0.36665    | 0.36665    | 0.36665    |   0.0 |  0.35
Other   |            | 0.05975    |            |       |  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 104.999 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.47     | 104.47     | 104.47     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099093   | 0.099093   | 0.099093   |   0.0 |  0.09
Output  | 0.00018492 | 0.00018492 | 0.00018492 |   0.0 |  0.00
Modify  | 0.37109    | 0.37109    | 0.37109    |   0.0 |  0.35
Other   |            | 0.05966    |            |       |  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 105.415 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.282 hours/ns, 9.486 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.88     | 104.88     | 104.88     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099461   | 0.099461   | 0.099461   |   0.0 |  0.09
Output  | 0.00015506 | 0.00015506 | 0.00015506 |   0.0 |  0.00
Modify  | 0.37125    | 0.37125    | 0.37125    |   0.0 |  0.35
Other   |            | 0.06044    |            |       |  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 109.266 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.352 hours/ns, 9.152 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.71     | 108.71     | 108.71     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10351    | 0.10351    | 0.10351    |   0.0 |  0.09
Output  | 0.00020025 | 0.00020025 | 0.00020025 |   0.0 |  0.00
Modify  | 0.39025    | 0.39025    | 0.39025    |   0.0 |  0.36
Other   |            | 0.0613     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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 104.012 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.892 hours/ns, 9.614 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.49     | 103.49     | 103.49     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098635   | 0.098635   | 0.098635   |   0.0 |  0.09
Output  | 0.00015489 | 0.00015489 | 0.00015489 |   0.0 |  0.00
Modify  | 0.36452    | 0.36452    | 0.36452    |   0.0 |  0.35
Other   |            | 0.05923    |            |       |  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 103.902 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.862 hours/ns, 9.624 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.38     | 103.38     | 103.38     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098539   | 0.098539   | 0.098539   |   0.0 |  0.09
Output  | 0.000218   | 0.000218   | 0.000218   |   0.0 |  0.00
Modify  | 0.3641     | 0.3641     | 0.3641     |   0.0 |  0.35
Other   |            | 0.05968    |            |       |  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 106.123 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.479 hours/ns, 9.423 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.59     | 105.59     | 105.59     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099932   | 0.099932   | 0.099932   |   0.0 |  0.09
Output  | 0.00015705 | 0.00015705 | 0.00015705 |   0.0 |  0.00
Modify  | 0.37414    | 0.37414    | 0.37414    |   0.0 |  0.35
Other   |            | 0.06031    |            |       |  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 102.941 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.595 hours/ns, 9.714 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.42     | 102.42     | 102.42     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097608   | 0.097608   | 0.097608   |   0.0 |  0.09
Output  | 0.00015461 | 0.00015461 | 0.00015461 |   0.0 |  0.00
Modify  | 0.36031    | 0.36031    | 0.36031    |   0.0 |  0.35
Other   |            | 0.05953    |            |       |  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 104.172 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.937 hours/ns, 9.599 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.65     | 103.65     | 103.65     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099163   | 0.099163   | 0.099163   |   0.0 |  0.10
Output  | 0.00015526 | 0.00015526 | 0.00015526 |   0.0 |  0.00
Modify  | 0.36736    | 0.36736    | 0.36736    |   0.0 |  0.35
Other   |            | 0.05973    |            |       |  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 106.103 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.473 hours/ns, 9.425 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.57     | 105.57     | 105.57     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10061    | 0.10061    | 0.10061    |   0.0 |  0.09
Output  | 0.00022194 | 0.00022194 | 0.00022194 |   0.0 |  0.00
Modify  | 0.37586    | 0.37586    | 0.37586    |   0.0 |  0.35
Other   |            | 0.06066    |            |       |  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 102.371 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.436 hours/ns, 9.768 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    | 101.86     | 101.86     | 101.86     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096773   | 0.096773   | 0.096773   |   0.0 |  0.09
Output  | 0.0001542  | 0.0001542  | 0.0001542  |   0.0 |  0.00
Modify  | 0.35953    | 0.35953    | 0.35953    |   0.0 |  0.35
Other   |            | 0.05951    |            |       |  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 101.873 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.848 ns/day, 28.298 hours/ns, 9.816 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    | 101.36     | 101.36     | 101.36     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096152   | 0.096152   | 0.096152   |   0.0 |  0.09
Output  | 0.00027096 | 0.00027096 | 0.00027096 |   0.0 |  0.00
Modify  | 0.35597    | 0.35597    | 0.35597    |   0.0 |  0.35
Other   |            | 0.05908    |            |       |  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 104.892 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.137 hours/ns, 9.534 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.37     | 104.37     | 104.37     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098668   | 0.098668   | 0.098668   |   0.0 |  0.09
Output  | 0.00020083 | 0.00020083 | 0.00020083 |   0.0 |  0.00
Modify  | 0.36809    | 0.36809    | 0.36809    |   0.0 |  0.35
Other   |            | 0.06002    |            |       |  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 102.4 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.444 hours/ns, 9.766 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    | 101.89     | 101.89     | 101.89     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097118   | 0.097118   | 0.097118   |   0.0 |  0.09
Output  | 0.00015431 | 0.00015431 | 0.00015431 |   0.0 |  0.00
Modify  | 0.35779    | 0.35779    | 0.35779    |   0.0 |  0.35
Other   |            | 0.05971    |            |       |  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 107.433 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.89     | 106.89     | 106.89     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10113    | 0.10113    | 0.10113    |   0.0 |  0.09
Output  | 0.00019073 | 0.00019073 | 0.00019073 |   0.0 |  0.00
Modify  | 0.38284    | 0.38284    | 0.38284    |   0.0 |  0.36
Other   |            | 0.06076    |            |       |  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