# 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.860342010855675*${_u_distance}
variable latticeconst_converted equal 2.860342010855675*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86034201085568
Lattice spacing in x,y,z = 2.8603420 2.8603420 2.8603420
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.603420 28.603420 28.603420)
  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.603420 28.603420 28.603420)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_FarkasCaro_2018_FeNiCrCoCu__MO_803527979660_000
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23402.0495396402 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_803527979660_000#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0    -8526.136    -8526.136   -8601.8833   -8601.8833       293.15       293.15     23402.05     23402.05     3457.233     3457.233 
    1000   -8544.4087   -8544.4087   -8616.6067   -8616.6067    279.41338    279.41338    23809.709    23809.709    1228.4522    1228.4522 
Loop time of 32.4354 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.664 ns/day, 9.010 hours/ns, 30.830 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.643     | 31.643     | 31.643     |   0.0 | 97.56
Neigh   | 0.19296    | 0.19296    | 0.19296    |   0.0 |  0.59
Comm    | 0.13925    | 0.13925    | 0.13925    |   0.0 |  0.43
Output  | 0.00023965 | 0.00023965 | 0.00023965 |   0.0 |  0.00
Modify  | 0.39328    | 0.39328    | 0.39328    |   0.0 |  1.21
Other   |            | 0.06718    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5375.00 ave        5375 max        5375 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:      326448.0 ave      326448 max      326448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326448
Ave neighs/atom = 163.22400
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8544.4087   -8544.4087   -8616.6067   -8616.6067    279.41338    279.41338    23809.709    23809.709    1228.4522    1228.4522 
    2000    -8589.958    -8589.958   -8664.2064   -8664.2064    287.34903    287.34903    23646.179    23646.179    138.60891    138.60891 
Loop time of 31.2417 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.766 ns/day, 8.678 hours/ns, 32.008 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    | 30.464     | 30.464     | 30.464     |   0.0 | 97.51
Neigh   | 0.23878    | 0.23878    | 0.23878    |   0.0 |  0.76
Comm    | 0.1263     | 0.1263     | 0.1263     |   0.0 |  0.40
Output  | 0.00018445 | 0.00018445 | 0.00018445 |   0.0 |  0.00
Modify  | 0.34756    | 0.34756    | 0.34756    |   0.0 |  1.11
Other   |            | 0.06451    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5382.00 ave        5382 max        5382 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:      328222.0 ave      328222 max      328222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328222
Ave neighs/atom = 164.11100
Neighbor list builds = 5
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -8589.958    -8589.958   -8664.2064   -8664.2064    287.34903    287.34903    23646.179    23646.179    138.60891    138.60891 
    3000   -8587.7877   -8587.7877   -8663.9287   -8663.9287    294.67336    294.67336    23662.179    23662.179    761.94898    761.94898 
Loop time of 30.8948 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.797 ns/day, 8.582 hours/ns, 32.368 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.355     | 30.355     | 30.355     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1236     | 0.1236     | 0.1236     |   0.0 |  0.40
Output  | 0.00028356 | 0.00028356 | 0.00028356 |   0.0 |  0.00
Modify  | 0.35054    | 0.35054    | 0.35054    |   0.0 |  1.13
Other   |            | 0.06529    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5378.00 ave        5378 max        5378 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:      327976.0 ave      327976 max      327976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327976
Ave neighs/atom = 163.98800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8587.7877   -8587.7877   -8663.9287   -8663.9287    294.67336    294.67336    23662.179    23662.179    761.94898    761.94898 
    4000   -8589.8254   -8589.8254   -8664.2679   -8664.2679    288.10014    288.10014     23696.37     23696.37    -3499.236    -3499.236 
Loop time of 30.8397 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.802 ns/day, 8.567 hours/ns, 32.426 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    | 30.298     | 30.298     | 30.298     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12337    | 0.12337    | 0.12337    |   0.0 |  0.40
Output  | 0.00018737 | 0.00018737 | 0.00018737 |   0.0 |  0.00
Modify  | 0.35181    | 0.35181    | 0.35181    |   0.0 |  1.14
Other   |            | 0.06622    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5390.00 ave        5390 max        5390 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:      327636.0 ave      327636 max      327636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327636
Ave neighs/atom = 163.81800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8589.8254   -8589.8254   -8664.2679   -8664.2679    288.10014    288.10014     23696.37     23696.37    -3499.236    -3499.236 
    5000   -8588.6777   -8588.6777   -8664.6868   -8664.6868    294.16298    294.16298    23647.574    23647.574    902.66837    902.66837 
Loop time of 31.0571 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.782 ns/day, 8.627 hours/ns, 32.199 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    | 30.511     | 30.511     | 30.511     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12496    | 0.12496    | 0.12496    |   0.0 |  0.40
Output  | 0.00015584 | 0.00015584 | 0.00015584 |   0.0 |  0.00
Modify  | 0.35662    | 0.35662    | 0.35662    |   0.0 |  1.15
Other   |            | 0.06484    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5385.00 ave        5385 max        5385 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:      327214.0 ave      327214 max      327214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327214
Ave neighs/atom = 163.60700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 295.42698970415, Press = -1047.28021423599
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8588.6777   -8588.6777   -8664.6868   -8664.6868    294.16298    294.16298    23647.574    23647.574    902.66837    902.66837 
    6000    -8589.157    -8589.157    -8665.221    -8665.221    294.37578    294.37578    23681.262    23681.262   -1746.6666   -1746.6666 
Loop time of 31.6428 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.730 ns/day, 8.790 hours/ns, 31.603 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    | 31.069     | 31.069     | 31.069     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12629    | 0.12629    | 0.12629    |   0.0 |  0.40
Output  | 0.0001545  | 0.0001545  | 0.0001545  |   0.0 |  0.00
Modify  | 0.3813     | 0.3813     | 0.3813     |   0.0 |  1.21
Other   |            | 0.06563    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5391.00 ave        5391 max        5391 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:      327994.0 ave      327994 max      327994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327994
Ave neighs/atom = 163.99700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 290.933363312724, Press = 38.4824046831113
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000    -8589.157    -8589.157    -8665.221    -8665.221    294.37578    294.37578    23681.262    23681.262   -1746.6666   -1746.6666 
    7000   -8588.6794   -8588.6794   -8664.6963   -8664.6963    294.19328    294.19328    23644.096    23644.096    685.72578    685.72578 
Loop time of 32.0228 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.698 ns/day, 8.895 hours/ns, 31.228 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    | 31.441     | 31.441     | 31.441     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12774    | 0.12774    | 0.12774    |   0.0 |  0.40
Output  | 0.00015658 | 0.00015658 | 0.00015658 |   0.0 |  0.00
Modify  | 0.38887    | 0.38887    | 0.38887    |   0.0 |  1.21
Other   |            | 0.06541    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5364.00 ave        5364 max        5364 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:      327136.0 ave      327136 max      327136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327136
Ave neighs/atom = 163.56800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.726570923165, Press = -6.26624667703212
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8588.6794   -8588.6794   -8664.6963   -8664.6963    294.19328    294.19328    23644.096    23644.096    685.72578    685.72578 
    8000   -8588.2855   -8588.2855   -8663.5977   -8663.5977    291.46619    291.46619    23664.514    23664.514    1447.2707    1447.2707 
Loop time of 32.0134 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.699 ns/day, 8.893 hours/ns, 31.237 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.431     | 31.431     | 31.431     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12748    | 0.12748    | 0.12748    |   0.0 |  0.40
Output  | 0.00019074 | 0.00019074 | 0.00019074 |   0.0 |  0.00
Modify  | 0.38867    | 0.38867    | 0.38867    |   0.0 |  1.21
Other   |            | 0.06569    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5385.00 ave        5385 max        5385 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:      327710.0 ave      327710 max      327710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327710
Ave neighs/atom = 163.85500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.059196110576, Press = -1.59943516000002
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8588.2855   -8588.2855   -8663.5977   -8663.5977    291.46619    291.46619    23664.514    23664.514    1447.2707    1447.2707 
    9000   -8588.1587   -8588.1587   -8664.3914   -8664.3914    295.02845    295.02845    23677.274    23677.274   -2671.4499   -2671.4499 
Loop time of 31.4789 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.745 ns/day, 8.744 hours/ns, 31.767 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    | 30.906     | 30.906     | 30.906     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12632    | 0.12632    | 0.12632    |   0.0 |  0.40
Output  | 0.00019493 | 0.00019493 | 0.00019493 |   0.0 |  0.00
Modify  | 0.38018    | 0.38018    | 0.38018    |   0.0 |  1.21
Other   |            | 0.06618    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5390.00 ave        5390 max        5390 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:      327292.0 ave      327292 max      327292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327292
Ave neighs/atom = 163.64600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.792231762279, Press = -11.4407676564769
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8588.1587   -8588.1587   -8664.3914   -8664.3914    295.02845    295.02845    23677.274    23677.274   -2671.4499   -2671.4499 
   10000   -8591.5555   -8591.5555   -8665.9158   -8665.9158    287.78185    287.78185    23625.223    23625.223    3048.5628    3048.5628 
Loop time of 31.5578 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.738 ns/day, 8.766 hours/ns, 31.688 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.986     | 30.986     | 30.986     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12649    | 0.12649    | 0.12649    |   0.0 |  0.40
Output  | 0.00019522 | 0.00019522 | 0.00019522 |   0.0 |  0.00
Modify  | 0.37966    | 0.37966    | 0.37966    |   0.0 |  1.20
Other   |            | 0.06585    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5388.00 ave        5388 max        5388 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:      327230.0 ave      327230 max      327230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327230
Ave neighs/atom = 163.61500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.690105843487, Press = -8.50743526958957
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8591.5555   -8591.5555   -8665.9158   -8665.9158    287.78185    287.78185    23625.223    23625.223    3048.5628    3048.5628 
   11000   -8586.4428   -8586.4428   -8664.6178   -8664.6178    302.54529    302.54529    23668.293    23668.293    292.51241    292.51241 
Loop time of 30.8718 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.799 ns/day, 8.576 hours/ns, 32.392 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    | 30.315     | 30.315     | 30.315     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12285    | 0.12285    | 0.12285    |   0.0 |  0.40
Output  | 0.00019144 | 0.00019144 | 0.00019144 |   0.0 |  0.00
Modify  | 0.36834    | 0.36834    | 0.36834    |   0.0 |  1.19
Other   |            | 0.06547    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5394.00 ave        5394 max        5394 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:      327968.0 ave      327968 max      327968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327968
Ave neighs/atom = 163.98400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.722776628493, Press = -10.1360642641809
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8586.4428   -8586.4428   -8664.6178   -8664.6178    302.54529    302.54529    23668.293    23668.293    292.51241    292.51241 
   12000   -8590.2672   -8590.2672   -8666.3744   -8666.3744    294.54254    294.54254    23627.669    23627.669     1499.047     1499.047 
Loop time of 31.7453 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.722 ns/day, 8.818 hours/ns, 31.501 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    | 31.17      | 31.17      | 31.17      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12598    | 0.12598    | 0.12598    |   0.0 |  0.40
Output  | 0.0002153  | 0.0002153  | 0.0002153  |   0.0 |  0.00
Modify  | 0.38343    | 0.38343    | 0.38343    |   0.0 |  1.21
Other   |            | 0.06553    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5368.00 ave        5368 max        5368 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:      327436.0 ave      327436 max      327436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327436
Ave neighs/atom = 163.71800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.784130898009, Press = 3.61722567480019
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8590.2672   -8590.2672   -8666.3744   -8666.3744    294.54254    294.54254    23627.669    23627.669     1499.047     1499.047 
   13000   -8588.3777   -8588.3777   -8664.9408   -8664.9408     296.3073     296.3073    23690.507    23690.507   -3285.7042   -3285.7042 
Loop time of 31.4822 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.744 ns/day, 8.745 hours/ns, 31.764 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.911     | 30.911     | 30.911     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12574    | 0.12574    | 0.12574    |   0.0 |  0.40
Output  | 0.00015192 | 0.00015192 | 0.00015192 |   0.0 |  0.00
Modify  | 0.37916    | 0.37916    | 0.37916    |   0.0 |  1.20
Other   |            | 0.0662     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5380.00 ave        5380 max        5380 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:      327924.0 ave      327924 max      327924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327924
Ave neighs/atom = 163.96200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.93146036822, Press = -6.69741901747948
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8588.3777   -8588.3777   -8664.9408   -8664.9408     296.3073     296.3073    23690.507    23690.507   -3285.7042   -3285.7042 
   14000   -8588.2941   -8588.2941   -8666.4688   -8666.4688    302.54425    302.54425    23624.067    23624.067    3286.9671    3286.9671 
Loop time of 31.2567 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.764 ns/day, 8.682 hours/ns, 31.993 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    | 30.691     | 30.691     | 30.691     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12429    | 0.12429    | 0.12429    |   0.0 |  0.40
Output  | 0.00015401 | 0.00015401 | 0.00015401 |   0.0 |  0.00
Modify  | 0.37545    | 0.37545    | 0.37545    |   0.0 |  1.20
Other   |            | 0.0654     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5376.00 ave        5376 max        5376 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:      326774.0 ave      326774 max      326774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326774
Ave neighs/atom = 163.38700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.965704287875, Press = -1.39403279756165
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8588.2941   -8588.2941   -8666.4688   -8666.4688    302.54425    302.54425    23624.067    23624.067    3286.9671    3286.9671 
   15000   -8589.7379   -8589.7379   -8665.4468   -8665.4468    293.00141    293.00141    23689.474    23689.474   -4184.9806   -4184.9806 
Loop time of 32.2796 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.677 ns/day, 8.967 hours/ns, 30.979 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    | 31.688     | 31.688     | 31.688     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13046    | 0.13046    | 0.13046    |   0.0 |  0.40
Output  | 0.00015319 | 0.00015319 | 0.00015319 |   0.0 |  0.00
Modify  | 0.39471    | 0.39471    | 0.39471    |   0.0 |  1.22
Other   |            | 0.06655    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5385.00 ave        5385 max        5385 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:      327838.0 ave      327838 max      327838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327838
Ave neighs/atom = 163.91900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.972310919299, Press = -2.00691967536614
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8589.7379   -8589.7379   -8665.4468   -8665.4468    293.00141    293.00141    23689.474    23689.474   -4184.9806   -4184.9806 
   16000   -8587.8874   -8587.8874   -8664.9119   -8664.9119    298.09283    298.09283    23622.699    23622.699    3673.3223    3673.3223 
Loop time of 31.3142 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.759 ns/day, 8.698 hours/ns, 31.934 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    | 30.743     | 30.743     | 30.743     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12492    | 0.12492    | 0.12492    |   0.0 |  0.40
Output  | 0.00019502 | 0.00019502 | 0.00019502 |   0.0 |  0.00
Modify  | 0.37924    | 0.37924    | 0.37924    |   0.0 |  1.21
Other   |            | 0.06637    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5366.00 ave        5366 max        5366 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:      326886.0 ave      326886 max      326886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326886
Ave neighs/atom = 163.44300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.140427800179, Press = -1.26162103715255
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8587.8874   -8587.8874   -8664.9119   -8664.9119    298.09283    298.09283    23622.699    23622.699    3673.3223    3673.3223 
   17000   -8592.0756   -8592.0756   -8666.6947   -8666.6947    288.78353    288.78353    23665.671    23665.671   -1699.7846   -1699.7846 
Loop time of 32.213 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.682 ns/day, 8.948 hours/ns, 31.043 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    | 31.627     | 31.627     | 31.627     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12896    | 0.12896    | 0.12896    |   0.0 |  0.40
Output  | 0.00015304 | 0.00015304 | 0.00015304 |   0.0 |  0.00
Modify  | 0.39143    | 0.39143    | 0.39143    |   0.0 |  1.22
Other   |            | 0.06553    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5408.00 ave        5408 max        5408 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:      328232.0 ave      328232 max      328232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328232
Ave neighs/atom = 164.11600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.152218117308, Press = -1.64143739347949
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8592.0756   -8592.0756   -8666.6947   -8666.6947    288.78353    288.78353    23665.671    23665.671   -1699.7846   -1699.7846 
   18000   -8587.1326   -8587.1326   -8663.5378   -8663.5378    295.69614    295.69614     23645.36     23645.36    1905.0824    1905.0824 
Loop time of 31.6339 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.731 ns/day, 8.787 hours/ns, 31.612 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    | 31.061     | 31.061     | 31.061     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12643    | 0.12643    | 0.12643    |   0.0 |  0.40
Output  | 0.00015326 | 0.00015326 | 0.00015326 |   0.0 |  0.00
Modify  | 0.38056    | 0.38056    | 0.38056    |   0.0 |  1.20
Other   |            | 0.06573    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5392.00 ave        5392 max        5392 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:      327184.0 ave      327184 max      327184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327184
Ave neighs/atom = 163.59200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.036399998794, Press = 1.95987819931079
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8587.1326   -8587.1326   -8663.5378   -8663.5378    295.69614    295.69614     23645.36     23645.36    1905.0824    1905.0824 
   19000   -8592.7135   -8592.7135   -8665.1365   -8665.1365     280.2843     280.2843    23637.397    23637.397    1476.9742    1476.9742 
Loop time of 31.9433 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.705 ns/day, 8.873 hours/ns, 31.305 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    | 31.362     | 31.362     | 31.362     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12725    | 0.12725    | 0.12725    |   0.0 |  0.40
Output  | 0.00019632 | 0.00019632 | 0.00019632 |   0.0 |  0.00
Modify  | 0.38775    | 0.38775    | 0.38775    |   0.0 |  1.21
Other   |            | 0.06623    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5373.00 ave        5373 max        5373 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:      327606.0 ave      327606 max      327606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327606
Ave neighs/atom = 163.80300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.870482140505, Press = -3.23497940650386
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8592.7135   -8592.7135   -8665.1365   -8665.1365     280.2843     280.2843    23637.397    23637.397    1476.9742    1476.9742 
   20000   -8586.9041   -8586.9041   -8663.5025   -8663.5025    296.44359    296.44359    23704.133    23704.133   -3929.6463   -3929.6463 
Loop time of 31.8244 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.715 ns/day, 8.840 hours/ns, 31.422 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.247     | 31.247     | 31.247     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12617    | 0.12617    | 0.12617    |   0.0 |  0.40
Output  | 0.00019595 | 0.00019595 | 0.00019595 |   0.0 |  0.00
Modify  | 0.38485    | 0.38485    | 0.38485    |   0.0 |  1.21
Other   |            | 0.06614    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5370.00 ave        5370 max        5370 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:      327594.0 ave      327594 max      327594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327594
Ave neighs/atom = 163.79700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.818715451298, Press = 0.310339405721463
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8586.9041   -8586.9041   -8663.5025   -8663.5025    296.44359    296.44359    23704.133    23704.133   -3929.6463   -3929.6463 
   21000   -8591.0013   -8591.0013   -8665.9613   -8665.9613    290.10299    290.10299    23635.344    23635.344    1894.2128    1894.2128 
Loop time of 31.4542 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.747 ns/day, 8.737 hours/ns, 31.792 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    | 30.885     | 30.885     | 30.885     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12473    | 0.12473    | 0.12473    |   0.0 |  0.40
Output  | 0.00015178 | 0.00015178 | 0.00015178 |   0.0 |  0.00
Modify  | 0.37934    | 0.37934    | 0.37934    |   0.0 |  1.21
Other   |            | 0.06521    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5373.00 ave        5373 max        5373 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:      326874.0 ave      326874 max      326874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326874
Ave neighs/atom = 163.43700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.778507411978, Press = -3.04882001213805
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8591.0013   -8591.0013   -8665.9613   -8665.9613    290.10299    290.10299    23635.344    23635.344    1894.2128    1894.2128 
   22000    -8592.093    -8592.093   -8666.0952   -8666.0952    286.39613    286.39613    23661.397    23661.397   -1443.1798   -1443.1798 
Loop time of 31.4128 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.750 ns/day, 8.726 hours/ns, 31.834 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    | 30.843     | 30.843     | 30.843     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12496    | 0.12496    | 0.12496    |   0.0 |  0.40
Output  | 0.00019828 | 0.00019828 | 0.00019828 |   0.0 |  0.00
Modify  | 0.37905    | 0.37905    | 0.37905    |   0.0 |  1.21
Other   |            | 0.06535    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5369.00 ave        5369 max        5369 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:      327784.0 ave      327784 max      327784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327784
Ave neighs/atom = 163.89200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.737721692565, Press = 3.88694861223132
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000    -8592.093    -8592.093   -8666.0952   -8666.0952    286.39613    286.39613    23661.397    23661.397   -1443.1798   -1443.1798 
   23000   -8589.0378   -8589.0378   -8664.7821   -8664.7821    293.13829    293.13829    23661.464    23661.464    453.71923    453.71923 
Loop time of 31.4852 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.744 ns/day, 8.746 hours/ns, 31.761 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    | 30.917     | 30.917     | 30.917     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12544    | 0.12544    | 0.12544    |   0.0 |  0.40
Output  | 0.0002114  | 0.0002114  | 0.0002114  |   0.0 |  0.00
Modify  | 0.3771     | 0.3771     | 0.3771     |   0.0 |  1.20
Other   |            | 0.06544    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5377.00 ave        5377 max        5377 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:      327352.0 ave      327352 max      327352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327352
Ave neighs/atom = 163.67600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.735049202616, Press = -3.27599515989928
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8589.0378   -8589.0378   -8664.7821   -8664.7821    293.13829    293.13829    23661.464    23661.464    453.71923    453.71923 
   24000   -8588.5179   -8588.5179   -8663.7289   -8663.7289    291.07437    291.07437    23665.911    23665.911   -1145.0495   -1145.0495 
Loop time of 31.1786 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.771 ns/day, 8.661 hours/ns, 32.073 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    | 30.614     | 30.614     | 30.614     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12452    | 0.12452    | 0.12452    |   0.0 |  0.40
Output  | 0.00014811 | 0.00014811 | 0.00014811 |   0.0 |  0.00
Modify  | 0.37382    | 0.37382    | 0.37382    |   0.0 |  1.20
Other   |            | 0.06614    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5377.00 ave        5377 max        5377 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:      327254.0 ave      327254 max      327254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327254
Ave neighs/atom = 163.62700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.815291789879, Press = 3.13184087845257
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8588.5179   -8588.5179   -8663.7289   -8663.7289    291.07437    291.07437    23665.911    23665.911   -1145.0495   -1145.0495 
   25000   -8589.8325   -8589.8325   -8666.9181   -8666.9181    298.32932    298.32932    23615.634    23615.634    3576.4257    3576.4257 
Loop time of 31.5879 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.735 ns/day, 8.774 hours/ns, 31.658 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    | 31.022     | 31.022     | 31.022     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12436    | 0.12436    | 0.12436    |   0.0 |  0.39
Output  | 0.00015616 | 0.00015616 | 0.00015616 |   0.0 |  0.00
Modify  | 0.37653    | 0.37653    | 0.37653    |   0.0 |  1.19
Other   |            | 0.06511    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5374.00 ave        5374 max        5374 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:      327394.0 ave      327394 max      327394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327394
Ave neighs/atom = 163.69700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.779383668398, Press = -4.91869645511571
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8589.8325   -8589.8325   -8666.9181   -8666.9181    298.32932    298.32932    23615.634    23615.634    3576.4257    3576.4257 
   26000   -8588.6618   -8588.6618   -8664.6225   -8664.6225     293.9759     293.9759    23664.688    23664.688   -1444.9103   -1444.9103 
Loop time of 32.028 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.698 ns/day, 8.897 hours/ns, 31.223 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    | 31.45      | 31.45      | 31.45      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12671    | 0.12671    | 0.12671    |   0.0 |  0.40
Output  | 0.00057331 | 0.00057331 | 0.00057331 |   0.0 |  0.00
Modify  | 0.38577    | 0.38577    | 0.38577    |   0.0 |  1.20
Other   |            | 0.06516    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5390.00 ave        5390 max        5390 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:      327908.0 ave      327908 max      327908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327908
Ave neighs/atom = 163.95400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.826293561846, Press = 0.900832616310269
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8588.6618   -8588.6618   -8664.6225   -8664.6225     293.9759     293.9759    23664.688    23664.688   -1444.9103   -1444.9103 
   27000   -8593.4733   -8593.4733   -8669.8556   -8669.8556    295.60729    295.60729    23634.817    23634.817    1508.8137    1508.8137 
Loop time of 31.2981 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.761 ns/day, 8.694 hours/ns, 31.951 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    | 30.732     | 30.732     | 30.732     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12487    | 0.12487    | 0.12487    |   0.0 |  0.40
Output  | 0.00015676 | 0.00015676 | 0.00015676 |   0.0 |  0.00
Modify  | 0.37492    | 0.37492    | 0.37492    |   0.0 |  1.20
Other   |            | 0.06578    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5365.00 ave        5365 max        5365 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:      327608.0 ave      327608 max      327608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327608
Ave neighs/atom = 163.80400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.756432766567, Press = -3.19465376630479
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8593.4733   -8593.4733   -8669.8556   -8669.8556    295.60729    295.60729    23634.817    23634.817    1508.8137    1508.8137 
   28000   -8589.4813   -8589.4813   -8664.9356   -8664.9356     292.0161     292.0161    23666.468    23666.468   -723.98988   -723.98988 
Loop time of 31.8942 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.709 ns/day, 8.859 hours/ns, 31.354 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    | 31.314     | 31.314     | 31.314     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12796    | 0.12796    | 0.12796    |   0.0 |  0.40
Output  | 0.00015229 | 0.00015229 | 0.00015229 |   0.0 |  0.00
Modify  | 0.38656    | 0.38656    | 0.38656    |   0.0 |  1.21
Other   |            | 0.0655     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5373.00 ave        5373 max        5373 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:      327834.0 ave      327834 max      327834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327834
Ave neighs/atom = 163.91700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.756557175448, Press = 0.286729789878474
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8589.4813   -8589.4813   -8664.9356   -8664.9356     292.0161     292.0161    23666.468    23666.468   -723.98988   -723.98988 
   29000   -8586.4514   -8586.4514   -8662.6496   -8662.6496    294.89476    294.89476    23672.527    23672.527   -1385.9658   -1385.9658 
Loop time of 31.9496 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.704 ns/day, 8.875 hours/ns, 31.299 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    | 31.369     | 31.369     | 31.369     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12704    | 0.12704    | 0.12704    |   0.0 |  0.40
Output  | 0.00016058 | 0.00016058 | 0.00016058 |   0.0 |  0.00
Modify  | 0.3882     | 0.3882     | 0.3882     |   0.0 |  1.22
Other   |            | 0.06506    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5398.00 ave        5398 max        5398 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:      327154.0 ave      327154 max      327154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327154
Ave neighs/atom = 163.57700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.831627223903, Press = -0.679598428986912
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8586.4514   -8586.4514   -8662.6496   -8662.6496    294.89476    294.89476    23672.527    23672.527   -1385.9658   -1385.9658 
   30000   -8589.9243   -8589.9243   -8665.2181   -8665.2181    291.39487    291.39487    23634.902    23634.902    1480.2045    1480.2045 
Loop time of 31.1849 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.771 ns/day, 8.662 hours/ns, 32.067 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    | 30.625     | 30.625     | 30.625     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12395    | 0.12395    | 0.12395    |   0.0 |  0.40
Output  | 0.00015469 | 0.00015469 | 0.00015469 |   0.0 |  0.00
Modify  | 0.3709     | 0.3709     | 0.3709     |   0.0 |  1.19
Other   |            | 0.06508    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5367.00 ave        5367 max        5367 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:      327274.0 ave      327274 max      327274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327274
Ave neighs/atom = 163.63700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.950875297403, Press = -1.24479904523147
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8589.9243   -8589.9243   -8665.2181   -8665.2181    291.39487    291.39487    23634.902    23634.902    1480.2045    1480.2045 
   31000   -8588.2152   -8588.2152   -8663.0458   -8663.0458    289.60205    289.60205    23663.203    23663.203     318.1352     318.1352 
Loop time of 31.6705 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.728 ns/day, 8.797 hours/ns, 31.575 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    | 31.094     | 31.094     | 31.094     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12612    | 0.12612    | 0.12612    |   0.0 |  0.40
Output  | 0.00015481 | 0.00015481 | 0.00015481 |   0.0 |  0.00
Modify  | 0.38488    | 0.38488    | 0.38488    |   0.0 |  1.22
Other   |            | 0.06522    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5359.00 ave        5359 max        5359 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:      327810.0 ave      327810 max      327810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327810
Ave neighs/atom = 163.90500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.990711117038, Press = 0.784596739679061
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8588.2152   -8588.2152   -8663.0458   -8663.0458    289.60205    289.60205    23663.203    23663.203     318.1352     318.1352 
   32000   -8592.5092   -8592.5092   -8665.5895   -8665.5895    282.82804    282.82804     23655.06     23655.06   -92.304381   -92.304381 
Loop time of 31.1109 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.777 ns/day, 8.642 hours/ns, 32.143 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    | 30.545     | 30.545     | 30.545     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12558    | 0.12558    | 0.12558    |   0.0 |  0.40
Output  | 0.00019439 | 0.00019439 | 0.00019439 |   0.0 |  0.00
Modify  | 0.37469    | 0.37469    | 0.37469    |   0.0 |  1.20
Other   |            | 0.06524    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5378.00 ave        5378 max        5378 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:      327432.0 ave      327432 max      327432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327432
Ave neighs/atom = 163.71600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.89570634448, Press = -2.24246875242812
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8592.5092   -8592.5092   -8665.5895   -8665.5895    282.82804    282.82804     23655.06     23655.06   -92.304381   -92.304381 
   33000    -8588.153    -8588.153   -8665.3178   -8665.3178    298.63582    298.63582    23662.376    23662.376   -996.04952   -996.04952 
Loop time of 31.6763 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.728 ns/day, 8.799 hours/ns, 31.569 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    | 31.102     | 31.102     | 31.102     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12568    | 0.12568    | 0.12568    |   0.0 |  0.40
Output  | 0.00015643 | 0.00015643 | 0.00015643 |   0.0 |  0.00
Modify  | 0.3825     | 0.3825     | 0.3825     |   0.0 |  1.21
Other   |            | 0.06595    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5391.00 ave        5391 max        5391 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:      327534.0 ave      327534 max      327534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327534
Ave neighs/atom = 163.76700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.897764652196, Press = -0.561890923062249
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    -8588.153    -8588.153   -8665.3178   -8665.3178    298.63582    298.63582    23662.376    23662.376   -996.04952   -996.04952 
   34000   -8588.1679   -8588.1679   -8664.4626   -8664.4626    295.26845    295.26845     23633.71     23633.71    1692.2363    1692.2363 
Loop time of 31.3275 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.758 ns/day, 8.702 hours/ns, 31.921 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    | 30.762     | 30.762     | 30.762     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12423    | 0.12423    | 0.12423    |   0.0 |  0.40
Output  | 0.0001536  | 0.0001536  | 0.0001536  |   0.0 |  0.00
Modify  | 0.37607    | 0.37607    | 0.37607    |   0.0 |  1.20
Other   |            | 0.06528    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5376.00 ave        5376 max        5376 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:      327366.0 ave      327366 max      327366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327366
Ave neighs/atom = 163.68300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.843950598486, Press = 1.23879604154244
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8588.1679   -8588.1679   -8664.4626   -8664.4626    295.26845    295.26845     23633.71     23633.71    1692.2363    1692.2363 
   35000   -8592.3304   -8592.3304   -8666.9138   -8666.9138    288.64534    288.64534    23633.589    23633.589    2073.2604    2073.2604 
Loop time of 31.3647 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.755 ns/day, 8.712 hours/ns, 31.883 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    | 30.791     | 30.791     | 30.791     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12595    | 0.12595    | 0.12595    |   0.0 |  0.40
Output  | 0.00016818 | 0.00016818 | 0.00016818 |   0.0 |  0.00
Modify  | 0.38153    | 0.38153    | 0.38153    |   0.0 |  1.22
Other   |            | 0.06593    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5380.00 ave        5380 max        5380 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:      327818.0 ave      327818 max      327818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327818
Ave neighs/atom = 163.90900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.787399717658, Press = -2.10874635349444
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8592.3304   -8592.3304   -8666.9138   -8666.9138    288.64534    288.64534    23633.589    23633.589    2073.2604    2073.2604 
   36000   -8589.3874   -8589.3874   -8664.5653   -8664.5653    290.94628    290.94628    23667.566    23667.566    -1799.171    -1799.171 
Loop time of 30.9786 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.789 ns/day, 8.605 hours/ns, 32.280 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    | 30.415     | 30.415     | 30.415     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12486    | 0.12486    | 0.12486    |   0.0 |  0.40
Output  | 0.00019732 | 0.00019732 | 0.00019732 |   0.0 |  0.00
Modify  | 0.37237    | 0.37237    | 0.37237    |   0.0 |  1.20
Other   |            | 0.06575    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5366.00 ave        5366 max        5366 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:      327970.0 ave      327970 max      327970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327970
Ave neighs/atom = 163.98500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.793192562921, Press = -0.65455795180103
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8589.3874   -8589.3874   -8664.5653   -8664.5653    290.94628    290.94628    23667.566    23667.566    -1799.171    -1799.171 
   37000   -8588.8461   -8588.8461   -8663.9712   -8663.9712    290.74196    290.74196     23659.76     23659.76    742.91101    742.91101 
Loop time of 31.0259 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.785 ns/day, 8.618 hours/ns, 32.231 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    | 30.459     | 30.459     | 30.459     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12505    | 0.12505    | 0.12505    |   0.0 |  0.40
Output  | 0.00015473 | 0.00015473 | 0.00015473 |   0.0 |  0.00
Modify  | 0.37594    | 0.37594    | 0.37594    |   0.0 |  1.21
Other   |            | 0.06588    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5371.00 ave        5371 max        5371 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:      327610.0 ave      327610 max      327610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327610
Ave neighs/atom = 163.80500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.794894755994, Press = 0.823501193480782
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8588.8461   -8588.8461   -8663.9712   -8663.9712    290.74196    290.74196     23659.76     23659.76    742.91101    742.91101 
   38000    -8589.522    -8589.522   -8665.3818   -8665.3818    293.58512    293.58512    23652.382    23652.382    1231.8379    1231.8379 
Loop time of 31.8173 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.716 ns/day, 8.838 hours/ns, 31.429 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    | 31.234     | 31.234     | 31.234     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12742    | 0.12742    | 0.12742    |   0.0 |  0.40
Output  | 0.00015568 | 0.00015568 | 0.00015568 |   0.0 |  0.00
Modify  | 0.38918    | 0.38918    | 0.38918    |   0.0 |  1.22
Other   |            | 0.06665    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5381.00 ave        5381 max        5381 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:      327536.0 ave      327536 max      327536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327536
Ave neighs/atom = 163.76800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.812665980052, Press = -4.70067518709979
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000    -8589.522    -8589.522   -8665.3818   -8665.3818    293.58512    293.58512    23652.382    23652.382    1231.8379    1231.8379 
   39000   -8585.4427   -8585.4427   -8663.8218   -8663.8218    303.33552    303.33552    23674.319    23674.319   -1566.4382   -1566.4382 
Loop time of 31.2254 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.767 ns/day, 8.674 hours/ns, 32.025 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    | 30.656     | 30.656     | 30.656     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12692    | 0.12692    | 0.12692    |   0.0 |  0.41
Output  | 0.00015385 | 0.00015385 | 0.00015385 |   0.0 |  0.00
Modify  | 0.37709    | 0.37709    | 0.37709    |   0.0 |  1.21
Other   |            | 0.06555    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5372.00 ave        5372 max        5372 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:      327452.0 ave      327452 max      327452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327452
Ave neighs/atom = 163.72600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.881782287432, Press = 1.87190770901629
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8585.4427   -8585.4427   -8663.8218   -8663.8218    303.33552    303.33552    23674.319    23674.319   -1566.4382   -1566.4382 
   40000   -8591.2574   -8591.2574   -8666.4861   -8666.4861    291.14287    291.14287    23673.111    23673.111   -2450.9742   -2450.9742 
Loop time of 31.6406 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.731 ns/day, 8.789 hours/ns, 31.605 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    | 31.069     | 31.069     | 31.069     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12575    | 0.12575    | 0.12575    |   0.0 |  0.40
Output  | 0.00019686 | 0.00019686 | 0.00019686 |   0.0 |  0.00
Modify  | 0.37938    | 0.37938    | 0.37938    |   0.0 |  1.20
Other   |            | 0.06621    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5373.00 ave        5373 max        5373 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:      327084.0 ave      327084 max      327084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327084
Ave neighs/atom = 163.54200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.921214198167, Press = -1.17990175950494
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8591.2574   -8591.2574   -8666.4861   -8666.4861    291.14287    291.14287    23673.111    23673.111   -2450.9742   -2450.9742 
   41000   -8587.8399   -8587.8399   -8665.4644   -8665.4644    300.41495    300.41495    23685.898    23685.898   -2904.8003   -2904.8003 
Loop time of 31.3806 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.753 ns/day, 8.717 hours/ns, 31.867 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    | 30.802     | 30.802     | 30.802     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12729    | 0.12729    | 0.12729    |   0.0 |  0.41
Output  | 0.00015442 | 0.00015442 | 0.00015442 |   0.0 |  0.00
Modify  | 0.38457    | 0.38457    | 0.38457    |   0.0 |  1.23
Other   |            | 0.06616    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5379.00 ave        5379 max        5379 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:      327042.0 ave      327042 max      327042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327042
Ave neighs/atom = 163.52100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.907847536609, Press = -0.226310317765601
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8587.8399   -8587.8399   -8665.4644   -8665.4644    300.41495    300.41495    23685.898    23685.898   -2904.8003   -2904.8003 
   42000   -8590.3759   -8590.3759   -8665.8499   -8665.8499    292.09201    292.09201    23648.297    23648.297    1190.2203    1190.2203 
Loop time of 31.6641 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.729 ns/day, 8.796 hours/ns, 31.581 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    | 31.084     | 31.084     | 31.084     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12664    | 0.12664    | 0.12664    |   0.0 |  0.40
Output  | 0.00015452 | 0.00015452 | 0.00015452 |   0.0 |  0.00
Modify  | 0.38697    | 0.38697    | 0.38697    |   0.0 |  1.22
Other   |            | 0.06612    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5387.00 ave        5387 max        5387 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:      327006.0 ave      327006 max      327006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327006
Ave neighs/atom = 163.50300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.902743915584, Press = -0.60948013462448
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8590.3759   -8590.3759   -8665.8499   -8665.8499    292.09201    292.09201    23648.297    23648.297    1190.2203    1190.2203 
   43000   -8585.5813   -8585.5813   -8661.9266   -8661.9266    295.46423    295.46423    23684.515    23684.515   -2127.2587   -2127.2587 
Loop time of 31.5271 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.740 ns/day, 8.758 hours/ns, 31.719 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    | 30.957     | 30.957     | 30.957     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12584    | 0.12584    | 0.12584    |   0.0 |  0.40
Output  | 0.0002018  | 0.0002018  | 0.0002018  |   0.0 |  0.00
Modify  | 0.37842    | 0.37842    | 0.37842    |   0.0 |  1.20
Other   |            | 0.06557    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5389.00 ave        5389 max        5389 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:      327508.0 ave      327508 max      327508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327508
Ave neighs/atom = 163.75400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.940865996702, Press = 0.144099001408352
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8585.5813   -8585.5813   -8661.9266   -8661.9266    295.46423    295.46423    23684.515    23684.515   -2127.2587   -2127.2587 
   44000    -8589.387    -8589.387   -8664.9748   -8664.9748    292.53249    292.53249    23679.012    23679.012   -1271.1811   -1271.1811 
Loop time of 31.9775 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.702 ns/day, 8.883 hours/ns, 31.272 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    | 31.395     | 31.395     | 31.395     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12816    | 0.12816    | 0.12816    |   0.0 |  0.40
Output  | 0.00015641 | 0.00015641 | 0.00015641 |   0.0 |  0.00
Modify  | 0.38778    | 0.38778    | 0.38778    |   0.0 |  1.21
Other   |            | 0.06603    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5353.00 ave        5353 max        5353 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:      327346.0 ave      327346 max      327346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327346
Ave neighs/atom = 163.67300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.977415591718, Press = -0.548412911443271
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000    -8589.387    -8589.387   -8664.9748   -8664.9748    292.53249    292.53249    23679.012    23679.012   -1271.1811   -1271.1811 
   45000   -8590.9927   -8590.9927   -8665.3897   -8665.3897    287.92415    287.92415    23652.832    23652.832    1056.3673    1056.3673 
Loop time of 31.0988 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.778 ns/day, 8.639 hours/ns, 32.156 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    | 30.541     | 30.541     | 30.541     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12302    | 0.12302    | 0.12302    |   0.0 |  0.40
Output  | 0.00019206 | 0.00019206 | 0.00019206 |   0.0 |  0.00
Modify  | 0.36984    | 0.36984    | 0.36984    |   0.0 |  1.19
Other   |            | 0.06481    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5360.00 ave        5360 max        5360 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:      327124.0 ave      327124 max      327124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327124
Ave neighs/atom = 163.56200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.029958552125, Press = -0.838896196348968
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -8590.9927   -8590.9927   -8665.3897   -8665.3897    287.92415    287.92415    23652.832    23652.832    1056.3673    1056.3673 
   46000   -8588.7037   -8588.7037   -8665.0866   -8665.0866    295.60995    295.60995     23652.37     23652.37    24.338684    24.338684 
Loop time of 31.4562 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.747 ns/day, 8.738 hours/ns, 31.790 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    | 30.884     | 30.884     | 30.884     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1253     | 0.1253     | 0.1253     |   0.0 |  0.40
Output  | 0.00015674 | 0.00015674 | 0.00015674 |   0.0 |  0.00
Modify  | 0.38189    | 0.38189    | 0.38189    |   0.0 |  1.21
Other   |            | 0.06526    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5364.00 ave        5364 max        5364 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:      327626.0 ave      327626 max      327626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327626
Ave neighs/atom = 163.81300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.01797682162, Press = -0.266448315440737
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8588.7037   -8588.7037   -8665.0866   -8665.0866    295.60995    295.60995     23652.37     23652.37    24.338684    24.338684 
   47000   -8587.5797   -8587.5797   -8664.7063   -8664.7063    298.48807    298.48807    23690.819    23690.819   -1930.4191   -1930.4191 
Loop time of 31.6276 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.732 ns/day, 8.785 hours/ns, 31.618 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    | 31.052     | 31.052     | 31.052     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.127      | 0.127      | 0.127      |   0.0 |  0.40
Output  | 0.00015477 | 0.00015477 | 0.00015477 |   0.0 |  0.00
Modify  | 0.38274    | 0.38274    | 0.38274    |   0.0 |  1.21
Other   |            | 0.06548    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5384.00 ave        5384 max        5384 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:      327468.0 ave      327468 max      327468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327468
Ave neighs/atom = 163.73400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.966550597659, Press = -2.60800954244363
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -8587.5797   -8587.5797   -8664.7063   -8664.7063    298.48807    298.48807    23690.819    23690.819   -1930.4191   -1930.4191 
   48000   -8593.3485   -8593.3485   -8668.3328   -8668.3328    290.19697    290.19697    23626.395    23626.395    2174.5224    2174.5224 
Loop time of 31.2342 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.766 ns/day, 8.676 hours/ns, 32.016 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    | 30.67      | 30.67      | 30.67      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12475    | 0.12475    | 0.12475    |   0.0 |  0.40
Output  | 0.00015385 | 0.00015385 | 0.00015385 |   0.0 |  0.00
Modify  | 0.37279    | 0.37279    | 0.37279    |   0.0 |  1.19
Other   |            | 0.06622    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5376.00 ave        5376 max        5376 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:      326612.0 ave      326612 max      326612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326612
Ave neighs/atom = 163.30600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.968699866101, Press = 1.38895301905247
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -8593.3485   -8593.3485   -8668.3328   -8668.3328    290.19697    290.19697    23626.395    23626.395    2174.5224    2174.5224 
   49000   -8587.4753   -8587.4753   -8664.7299   -8664.7299    298.98323    298.98323    23673.088    23673.088   -966.12954   -966.12954 
Loop time of 31.5919 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.735 ns/day, 8.776 hours/ns, 31.654 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    | 31.02      | 31.02      | 31.02      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12573    | 0.12573    | 0.12573    |   0.0 |  0.40
Output  | 0.00015431 | 0.00015431 | 0.00015431 |   0.0 |  0.00
Modify  | 0.38106    | 0.38106    | 0.38106    |   0.0 |  1.21
Other   |            | 0.06527    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5391.00 ave        5391 max        5391 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:      328126.0 ave      328126 max      328126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328126
Ave neighs/atom = 164.06300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.923735142194, Press = -2.58200574828772
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -8587.4753   -8587.4753   -8664.7299   -8664.7299    298.98323    298.98323    23673.088    23673.088   -966.12954   -966.12954 
   50000   -8589.3232   -8589.3232   -8664.3075   -8664.3075    290.19721    290.19721    23651.862    23651.862    184.68597    184.68597 
Loop time of 31.7075 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.725 ns/day, 8.808 hours/ns, 31.538 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    | 31.13      | 31.13      | 31.13      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12785    | 0.12785    | 0.12785    |   0.0 |  0.40
Output  | 0.00015536 | 0.00015536 | 0.00015536 |   0.0 |  0.00
Modify  | 0.38331    | 0.38331    | 0.38331    |   0.0 |  1.21
Other   |            | 0.06618    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5394.00 ave        5394 max        5394 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:      327168.0 ave      327168 max      327168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327168
Ave neighs/atom = 163.58400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.915003656945, Press = 0.717009166281151
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -8589.3232   -8589.3232   -8664.3075   -8664.3075    290.19721    290.19721    23651.862    23651.862    184.68597    184.68597 
   51000   -8591.6339   -8591.6339   -8664.6014   -8664.6014    282.39177    282.39177     23655.79     23655.79    756.94216    756.94216 
Loop time of 31.2495 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.765 ns/day, 8.680 hours/ns, 32.001 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    | 30.686     | 30.686     | 30.686     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12509    | 0.12509    | 0.12509    |   0.0 |  0.40
Output  | 0.00015718 | 0.00015718 | 0.00015718 |   0.0 |  0.00
Modify  | 0.37323    | 0.37323    | 0.37323    |   0.0 |  1.19
Other   |            | 0.06517    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5390.00 ave        5390 max        5390 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:      327592.0 ave      327592 max      327592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327592
Ave neighs/atom = 163.79600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.927751560339, Press = 0.140816070324463
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -8591.6339   -8591.6339   -8664.6014   -8664.6014    282.39177    282.39177     23655.79     23655.79    756.94216    756.94216 
   52000   -8587.1185   -8587.1185   -8664.2185   -8664.2185    298.38511    298.38511    23679.512    23679.512   -2629.9138   -2629.9138 
Loop time of 31.4024 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.751 ns/day, 8.723 hours/ns, 31.845 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    | 30.829     | 30.829     | 30.829     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12576    | 0.12576    | 0.12576    |   0.0 |  0.40
Output  | 0.00020347 | 0.00020347 | 0.00020347 |   0.0 |  0.00
Modify  | 0.38134    | 0.38134    | 0.38134    |   0.0 |  1.21
Other   |            | 0.06606    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5381.00 ave        5381 max        5381 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:      327644.0 ave      327644 max      327644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327644
Ave neighs/atom = 163.82200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.943523393146, Press = -1.51498807455991
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -8587.1185   -8587.1185   -8664.2185   -8664.2185    298.38511    298.38511    23679.512    23679.512   -2629.9138   -2629.9138 
   53000   -8590.5865   -8590.5865   -8666.3239   -8666.3239    293.11135    293.11135    23634.682    23634.682    1527.3175    1527.3175 
Loop time of 31.1752 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.771 ns/day, 8.660 hours/ns, 32.077 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    | 30.608     | 30.608     | 30.608     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12475    | 0.12475    | 0.12475    |   0.0 |  0.40
Output  | 0.00015842 | 0.00015842 | 0.00015842 |   0.0 |  0.00
Modify  | 0.37654    | 0.37654    | 0.37654    |   0.0 |  1.21
Other   |            | 0.06546    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5360.00 ave        5360 max        5360 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:      327052.0 ave      327052 max      327052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327052
Ave neighs/atom = 163.52600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.976499078643, Press = 1.44965222471658
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -8590.5865   -8590.5865   -8666.3239   -8666.3239    293.11135    293.11135    23634.682    23634.682    1527.3175    1527.3175 
   54000   -8586.8654   -8586.8654   -8662.9917   -8662.9917    294.61644    294.61644    23667.678    23667.678    146.26169    146.26169 
Loop time of 30.9264 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.794 ns/day, 8.591 hours/ns, 32.335 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    | 30.364     | 30.364     | 30.364     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12303    | 0.12303    | 0.12303    |   0.0 |  0.40
Output  | 0.00015424 | 0.00015424 | 0.00015424 |   0.0 |  0.00
Modify  | 0.37375    | 0.37375    | 0.37375    |   0.0 |  1.21
Other   |            | 0.06555    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5378.00 ave        5378 max        5378 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:      327770.0 ave      327770 max      327770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327770
Ave neighs/atom = 163.88500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.0132479347, Press = -0.961384805629312
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 = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -8586.8654   -8586.8654   -8662.9917   -8662.9917    294.61644    294.61644    23667.678    23667.678    146.26169    146.26169 
   55000   -8592.7301   -8592.7301   -8665.2388   -8665.2388     280.6163     280.6163    23647.264    23647.264    942.27143    942.27143 
Loop time of 31.1539 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.773 ns/day, 8.654 hours/ns, 32.099 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    | 30.597     | 30.597     | 30.597     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12301    | 0.12301    | 0.12301    |   0.0 |  0.39
Output  | 0.00015502 | 0.00015502 | 0.00015502 |   0.0 |  0.00
Modify  | 0.36857    | 0.36857    | 0.36857    |   0.0 |  1.18
Other   |            | 0.06467    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5376.00 ave        5376 max        5376 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:      327280.0 ave      327280 max      327280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327280
Ave neighs/atom = 163.64000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
23658.1606359418

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0