# 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_2020_FeNiCrCoAl__MO_820335782779_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_820335782779_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 33.9623 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.544 ns/day, 9.434 hours/ns, 29.444 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    | 33.157     | 33.157     | 33.157     |   0.0 | 97.63
Neigh   | 0.19016    | 0.19016    | 0.19016    |   0.0 |  0.56
Comm    | 0.14527    | 0.14527    | 0.14527    |   0.0 |  0.43
Output  | 0.00022976 | 0.00022976 | 0.00022976 |   0.0 |  0.00
Modify  | 0.40236    | 0.40236    | 0.40236    |   0.0 |  1.18
Other   |            | 0.06766    |            |       |  0.20

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.7378 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.722 ns/day, 8.816 hours/ns, 31.508 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.953     | 30.953     | 30.953     |   0.0 | 97.53
Neigh   | 0.23799    | 0.23799    | 0.23799    |   0.0 |  0.75
Comm    | 0.12996    | 0.12996    | 0.12996    |   0.0 |  0.41
Output  | 0.00023427 | 0.00023427 | 0.00023427 |   0.0 |  0.00
Modify  | 0.35289    | 0.35289    | 0.35289    |   0.0 |  1.11
Other   |            | 0.06394    |            |       |  0.20

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.7477 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.810 ns/day, 8.541 hours/ns, 32.523 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.212     | 30.212     | 30.212     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12499    | 0.12499    | 0.12499    |   0.0 |  0.41
Output  | 0.00019416 | 0.00019416 | 0.00019416 |   0.0 |  0.00
Modify  | 0.34621    | 0.34621    | 0.34621    |   0.0 |  1.13
Other   |            | 0.06452    |            |       |  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.8101 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.804 ns/day, 8.558 hours/ns, 32.457 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.274     | 30.274     | 30.274     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1245     | 0.1245     | 0.1245     |   0.0 |  0.40
Output  | 0.00018731 | 0.00018731 | 0.00018731 |   0.0 |  0.00
Modify  | 0.34703    | 0.34703    | 0.34703    |   0.0 |  1.13
Other   |            | 0.06423    |            |       |  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 30.9488 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.792 ns/day, 8.597 hours/ns, 32.311 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.405     | 30.405     | 30.405     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12422    | 0.12422    | 0.12422    |   0.0 |  0.40
Output  | 0.00015455 | 0.00015455 | 0.00015455 |   0.0 |  0.00
Modify  | 0.3546     | 0.3546     | 0.3546     |   0.0 |  1.15
Other   |            | 0.06486    |            |       |  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.8754 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.711 ns/day, 8.854 hours/ns, 31.372 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.301     | 31.301     | 31.301     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12803    | 0.12803    | 0.12803    |   0.0 |  0.40
Output  | 0.00019937 | 0.00019937 | 0.00019937 |   0.0 |  0.00
Modify  | 0.38109    | 0.38109    | 0.38109    |   0.0 |  1.20
Other   |            | 0.06492    |            |       |  0.20

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.0815 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.693 ns/day, 8.912 hours/ns, 31.171 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.496     | 31.496     | 31.496     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12848    | 0.12848    | 0.12848    |   0.0 |  0.40
Output  | 0.00015592 | 0.00015592 | 0.00015592 |   0.0 |  0.00
Modify  | 0.39162    | 0.39162    | 0.39162    |   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:        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 31.7608 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.720 ns/day, 8.822 hours/ns, 31.485 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.188     | 31.188     | 31.188     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12802    | 0.12802    | 0.12802    |   0.0 |  0.40
Output  | 0.00015452 | 0.00015452 | 0.00015452 |   0.0 |  0.00
Modify  | 0.3792     | 0.3792     | 0.3792     |   0.0 |  1.19
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:        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 32.322 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.673 ns/day, 8.978 hours/ns, 30.939 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.732     | 31.732     | 31.732     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12962    | 0.12962    | 0.12962    |   0.0 |  0.40
Output  | 0.00019416 | 0.00019416 | 0.00019416 |   0.0 |  0.00
Modify  | 0.39435    | 0.39435    | 0.39435    |   0.0 |  1.22
Other   |            | 0.06609    |            |       |  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:      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.9574 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.704 ns/day, 8.877 hours/ns, 31.292 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.378     | 31.378     | 31.378     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12863    | 0.12863    | 0.12863    |   0.0 |  0.40
Output  | 0.00015627 | 0.00015627 | 0.00015627 |   0.0 |  0.00
Modify  | 0.38487    | 0.38487    | 0.38487    |   0.0 |  1.20
Other   |            | 0.06564    |            |       |  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 31.9361 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.705 ns/day, 8.871 hours/ns, 31.312 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.355     | 31.355     | 31.355     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12937    | 0.12937    | 0.12937    |   0.0 |  0.41
Output  | 0.00015432 | 0.00015432 | 0.00015432 |   0.0 |  0.00
Modify  | 0.38607    | 0.38607    | 0.38607    |   0.0 |  1.21
Other   |            | 0.0658     |            |       |  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.4197 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.750 ns/day, 8.728 hours/ns, 31.827 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.849     | 30.849     | 30.849     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12693    | 0.12693    | 0.12693    |   0.0 |  0.40
Output  | 0.00015622 | 0.00015622 | 0.00015622 |   0.0 |  0.00
Modify  | 0.37756    | 0.37756    | 0.37756    |   0.0 |  1.20
Other   |            | 0.06562    |            |       |  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 32.4824 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.660 ns/day, 9.023 hours/ns, 30.786 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.883     | 31.883     | 31.883     |   0.0 | 98.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13171    | 0.13171    | 0.13171    |   0.0 |  0.41
Output  | 0.00019521 | 0.00019521 | 0.00019521 |   0.0 |  0.00
Modify  | 0.40077    | 0.40077    | 0.40077    |   0.0 |  1.23
Other   |            | 0.06667    |            |       |  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 32.0541 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.695 ns/day, 8.904 hours/ns, 31.197 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.473     | 31.473     | 31.473     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12835    | 0.12835    | 0.12835    |   0.0 |  0.40
Output  | 0.00015317 | 0.00015317 | 0.00015317 |   0.0 |  0.00
Modify  | 0.38775    | 0.38775    | 0.38775    |   0.0 |  1.21
Other   |            | 0.06501    |            |       |  0.20

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 31.6245 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.732 ns/day, 8.785 hours/ns, 31.621 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.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12747    | 0.12747    | 0.12747    |   0.0 |  0.40
Output  | 0.00015247 | 0.00015247 | 0.00015247 |   0.0 |  0.00
Modify  | 0.37927    | 0.37927    | 0.37927    |   0.0 |  1.20
Other   |            | 0.06558    |            |       |  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.8843 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.710 ns/day, 8.857 hours/ns, 31.363 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    | 31.297     | 31.297     | 31.297     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12932    | 0.12932    | 0.12932    |   0.0 |  0.41
Output  | 0.00014863 | 0.00014863 | 0.00014863 |   0.0 |  0.00
Modify  | 0.39242    | 0.39242    | 0.39242    |   0.0 |  1.23
Other   |            | 0.0659     |            |       |  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 31.8261 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.715 ns/day, 8.841 hours/ns, 31.421 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.251     | 31.251     | 31.251     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12775    | 0.12775    | 0.12775    |   0.0 |  0.40
Output  | 0.00020049 | 0.00020049 | 0.00020049 |   0.0 |  0.00
Modify  | 0.38216    | 0.38216    | 0.38216    |   0.0 |  1.20
Other   |            | 0.06491    |            |       |  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 32.2807 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.677 ns/day, 8.967 hours/ns, 30.978 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.693     | 31.693     | 31.693     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13057    | 0.13057    | 0.13057    |   0.0 |  0.40
Output  | 0.00015531 | 0.00015531 | 0.00015531 |   0.0 |  0.00
Modify  | 0.39131    | 0.39131    | 0.39131    |   0.0 |  1.21
Other   |            | 0.06611    |            |       |  0.20

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 32.1165 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.690 ns/day, 8.921 hours/ns, 31.137 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.535     | 31.535     | 31.535     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12843    | 0.12843    | 0.12843    |   0.0 |  0.40
Output  | 0.0002359  | 0.0002359  | 0.0002359  |   0.0 |  0.00
Modify  | 0.38743    | 0.38743    | 0.38743    |   0.0 |  1.21
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:        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 32.2281 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.681 ns/day, 8.952 hours/ns, 31.029 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.644     | 31.644     | 31.644     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12936    | 0.12936    | 0.12936    |   0.0 |  0.40
Output  | 0.00015498 | 0.00015498 | 0.00015498 |   0.0 |  0.00
Modify  | 0.38912    | 0.38912    | 0.38912    |   0.0 |  1.21
Other   |            | 0.06535    |            |       |  0.20

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.5978 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.734 ns/day, 8.777 hours/ns, 31.648 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.024     | 31.024     | 31.024     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12737    | 0.12737    | 0.12737    |   0.0 |  0.40
Output  | 0.00015643 | 0.00015643 | 0.00015643 |   0.0 |  0.00
Modify  | 0.38096    | 0.38096    | 0.38096    |   0.0 |  1.21
Other   |            | 0.0652     |            |       |  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.2902 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.761 ns/day, 8.692 hours/ns, 31.959 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.722     | 30.722     | 30.722     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12627    | 0.12627    | 0.12627    |   0.0 |  0.40
Output  | 0.00019703 | 0.00019703 | 0.00019703 |   0.0 |  0.00
Modify  | 0.37671    | 0.37671    | 0.37671    |   0.0 |  1.20
Other   |            | 0.0646     |            |       |  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.7611 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.720 ns/day, 8.823 hours/ns, 31.485 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.178     | 31.178     | 31.178     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12917    | 0.12917    | 0.12917    |   0.0 |  0.41
Output  | 0.00019173 | 0.00019173 | 0.00019173 |   0.0 |  0.00
Modify  | 0.38783    | 0.38783    | 0.38783    |   0.0 |  1.22
Other   |            | 0.06583    |            |       |  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 32.3479 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.671 ns/day, 8.986 hours/ns, 30.914 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.761     | 31.761     | 31.761     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13038    | 0.13038    | 0.13038    |   0.0 |  0.40
Output  | 0.0001519  | 0.0001519  | 0.0001519  |   0.0 |  0.00
Modify  | 0.39072    | 0.39072    | 0.39072    |   0.0 |  1.21
Other   |            | 0.06596    |            |       |  0.20

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 32.5956 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.651 ns/day, 9.054 hours/ns, 30.679 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.995     | 31.995     | 31.995     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13269    | 0.13269    | 0.13269    |   0.0 |  0.41
Output  | 0.00015425 | 0.00015425 | 0.00015425 |   0.0 |  0.00
Modify  | 0.40082    | 0.40082    | 0.40082    |   0.0 |  1.23
Other   |            | 0.06651    |            |       |  0.20

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 31.7684 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.720 ns/day, 8.825 hours/ns, 31.478 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.189     | 31.189     | 31.189     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12844    | 0.12844    | 0.12844    |   0.0 |  0.40
Output  | 0.00038817 | 0.00038817 | 0.00038817 |   0.0 |  0.00
Modify  | 0.385      | 0.385      | 0.385      |   0.0 |  1.21
Other   |            | 0.06568    |            |       |  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:      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.6577 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.729 ns/day, 8.794 hours/ns, 31.588 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.086     | 31.086     | 31.086     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12692    | 0.12692    | 0.12692    |   0.0 |  0.40
Output  | 0.00015507 | 0.00015507 | 0.00015507 |   0.0 |  0.00
Modify  | 0.37964    | 0.37964    | 0.37964    |   0.0 |  1.20
Other   |            | 0.0652     |            |       |  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.9222 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.707 ns/day, 8.867 hours/ns, 31.326 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.344     | 31.344     | 31.344     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12798    | 0.12798    | 0.12798    |   0.0 |  0.40
Output  | 0.00015614 | 0.00015614 | 0.00015614 |   0.0 |  0.00
Modify  | 0.38514    | 0.38514    | 0.38514    |   0.0 |  1.21
Other   |            | 0.0654     |            |       |  0.20

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 30.9757 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.789 ns/day, 8.604 hours/ns, 32.283 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.416     | 30.416     | 30.416     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12583    | 0.12583    | 0.12583    |   0.0 |  0.41
Output  | 0.00015274 | 0.00015274 | 0.00015274 |   0.0 |  0.00
Modify  | 0.36948    | 0.36948    | 0.36948    |   0.0 |  1.19
Other   |            | 0.06435    |            |       |  0.21

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.2758 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.763 ns/day, 8.688 hours/ns, 31.974 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.711     | 30.711     | 30.711     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12689    | 0.12689    | 0.12689    |   0.0 |  0.41
Output  | 0.00015443 | 0.00015443 | 0.00015443 |   0.0 |  0.00
Modify  | 0.37323    | 0.37323    | 0.37323    |   0.0 |  1.19
Other   |            | 0.0645     |            |       |  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.7947 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.717 ns/day, 8.832 hours/ns, 31.452 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.216     | 31.216     | 31.216     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12787    | 0.12787    | 0.12787    |   0.0 |  0.40
Output  | 0.00019474 | 0.00019474 | 0.00019474 |   0.0 |  0.00
Modify  | 0.38525    | 0.38525    | 0.38525    |   0.0 |  1.21
Other   |            | 0.06525    |            |       |  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.2503 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.765 ns/day, 8.681 hours/ns, 32.000 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.683     | 30.683     | 30.683     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12672    | 0.12672    | 0.12672    |   0.0 |  0.41
Output  | 0.00020235 | 0.00020235 | 0.00020235 |   0.0 |  0.00
Modify  | 0.3749     | 0.3749     | 0.3749     |   0.0 |  1.20
Other   |            | 0.06562    |            |       |  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.4134 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.846     | 30.846     | 30.846     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12677    | 0.12677    | 0.12677    |   0.0 |  0.40
Output  | 0.0002007  | 0.0002007  | 0.0002007  |   0.0 |  0.00
Modify  | 0.3761     | 0.3761     | 0.3761     |   0.0 |  1.20
Other   |            | 0.06462    |            |       |  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.3329 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.757 ns/day, 8.704 hours/ns, 31.915 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.765     | 30.765     | 30.765     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12594    | 0.12594    | 0.12594    |   0.0 |  0.40
Output  | 0.00015775 | 0.00015775 | 0.00015775 |   0.0 |  0.00
Modify  | 0.37751    | 0.37751    | 0.37751    |   0.0 |  1.20
Other   |            | 0.0648     |            |       |  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 32.0694 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.694 ns/day, 8.908 hours/ns, 31.182 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.483     | 31.483     | 31.483     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12961    | 0.12961    | 0.12961    |   0.0 |  0.40
Output  | 0.00014858 | 0.00014858 | 0.00014858 |   0.0 |  0.00
Modify  | 0.3911     | 0.3911     | 0.3911     |   0.0 |  1.22
Other   |            | 0.06573    |            |       |  0.20

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 31.2564 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.69      | 30.69      | 30.69      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12578    | 0.12578    | 0.12578    |   0.0 |  0.40
Output  | 0.00015203 | 0.00015203 | 0.00015203 |   0.0 |  0.00
Modify  | 0.37644    | 0.37644    | 0.37644    |   0.0 |  1.20
Other   |            | 0.06449    |            |       |  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.3991 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.752 ns/day, 8.722 hours/ns, 31.848 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.833     | 30.833     | 30.833     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12599    | 0.12599    | 0.12599    |   0.0 |  0.40
Output  | 0.00015769 | 0.00015769 | 0.00015769 |   0.0 |  0.00
Modify  | 0.37433    | 0.37433    | 0.37433    |   0.0 |  1.19
Other   |            | 0.06531    |            |       |  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.5756 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.736 ns/day, 8.771 hours/ns, 31.670 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.001     | 31.001     | 31.001     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12705    | 0.12705    | 0.12705    |   0.0 |  0.40
Output  | 0.00015446 | 0.00015446 | 0.00015446 |   0.0 |  0.00
Modify  | 0.3816     | 0.3816     | 0.3816     |   0.0 |  1.21
Other   |            | 0.06568    |            |       |  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.6192 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.733 ns/day, 8.783 hours/ns, 31.626 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.051     | 31.051     | 31.051     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12696    | 0.12696    | 0.12696    |   0.0 |  0.40
Output  | 0.00015876 | 0.00015876 | 0.00015876 |   0.0 |  0.00
Modify  | 0.37641    | 0.37641    | 0.37641    |   0.0 |  1.19
Other   |            | 0.06431    |            |       |  0.20

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.6302 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.732 ns/day, 8.786 hours/ns, 31.615 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.053     | 31.053     | 31.053     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12846    | 0.12846    | 0.12846    |   0.0 |  0.41
Output  | 0.00015446 | 0.00015446 | 0.00015446 |   0.0 |  0.00
Modify  | 0.38244    | 0.38244    | 0.38244    |   0.0 |  1.21
Other   |            | 0.06568    |            |       |  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.5107 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.742 ns/day, 8.753 hours/ns, 31.735 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.939     | 30.939     | 30.939     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12708    | 0.12708    | 0.12708    |   0.0 |  0.40
Output  | 0.00015406 | 0.00015406 | 0.00015406 |   0.0 |  0.00
Modify  | 0.3799     | 0.3799     | 0.3799     |   0.0 |  1.21
Other   |            | 0.06482    |            |       |  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.4091 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.751 ns/day, 8.725 hours/ns, 31.838 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.836     | 30.836     | 30.836     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12722    | 0.12722    | 0.12722    |   0.0 |  0.41
Output  | 0.0001533  | 0.0001533  | 0.0001533  |   0.0 |  0.00
Modify  | 0.37975    | 0.37975    | 0.37975    |   0.0 |  1.21
Other   |            | 0.06551    |            |       |  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.7533 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.721 ns/day, 8.820 hours/ns, 31.493 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.171     | 31.171     | 31.171     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12909    | 0.12909    | 0.12909    |   0.0 |  0.41
Output  | 0.00015533 | 0.00015533 | 0.00015533 |   0.0 |  0.00
Modify  | 0.38699    | 0.38699    | 0.38699    |   0.0 |  1.22
Other   |            | 0.06619    |            |       |  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.3184 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.759 ns/day, 8.700 hours/ns, 31.930 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.751     | 30.751     | 30.751     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1263     | 0.1263     | 0.1263     |   0.0 |  0.40
Output  | 0.00015581 | 0.00015581 | 0.00015581 |   0.0 |  0.00
Modify  | 0.37597    | 0.37597    | 0.37597    |   0.0 |  1.20
Other   |            | 0.06476    |            |       |  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.2318 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.766 ns/day, 8.676 hours/ns, 32.019 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.669     | 30.669     | 30.669     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12565    | 0.12565    | 0.12565    |   0.0 |  0.40
Output  | 0.00015216 | 0.00015216 | 0.00015216 |   0.0 |  0.00
Modify  | 0.37224    | 0.37224    | 0.37224    |   0.0 |  1.19
Other   |            | 0.06462    |            |       |  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.4387 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.748 ns/day, 8.733 hours/ns, 31.808 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.866     | 30.866     | 30.866     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12646    | 0.12646    | 0.12646    |   0.0 |  0.40
Output  | 0.00015568 | 0.00015568 | 0.00015568 |   0.0 |  0.00
Modify  | 0.38094    | 0.38094    | 0.38094    |   0.0 |  1.21
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:        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.1054 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.778 ns/day, 8.640 hours/ns, 32.149 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.54      | 30.54      | 30.54      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12661    | 0.12661    | 0.12661    |   0.0 |  0.41
Output  | 0.00015496 | 0.00015496 | 0.00015496 |   0.0 |  0.00
Modify  | 0.37459    | 0.37459    | 0.37459    |   0.0 |  1.20
Other   |            | 0.06404    |            |       |  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.7347 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.723 ns/day, 8.815 hours/ns, 31.511 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.16      | 31.16      | 31.16      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12793    | 0.12793    | 0.12793    |   0.0 |  0.40
Output  | 0.00015284 | 0.00015284 | 0.00015284 |   0.0 |  0.00
Modify  | 0.38108    | 0.38108    | 0.38108    |   0.0 |  1.20
Other   |            | 0.06532    |            |       |  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 32.2125 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.682 ns/day, 8.948 hours/ns, 31.044 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.625     | 31.625     | 31.625     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13077    | 0.13077    | 0.13077    |   0.0 |  0.41
Output  | 0.00019773 | 0.00019773 | 0.00019773 |   0.0 |  0.00
Modify  | 0.38995    | 0.38995    | 0.38995    |   0.0 |  1.21
Other   |            | 0.06631    |            |       |  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.7558 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.721 ns/day, 8.821 hours/ns, 31.490 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.18      | 31.18      | 31.18      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12837    | 0.12837    | 0.12837    |   0.0 |  0.40
Output  | 0.00015126 | 0.00015126 | 0.00015126 |   0.0 |  0.00
Modify  | 0.38208    | 0.38208    | 0.38208    |   0.0 |  1.20
Other   |            | 0.06519    |            |       |  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.6957 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.726 ns/day, 8.804 hours/ns, 31.550 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.12      | 31.12      | 31.12      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12826    | 0.12826    | 0.12826    |   0.0 |  0.40
Output  | 0.00019484 | 0.00019484 | 0.00019484 |   0.0 |  0.00
Modify  | 0.38164    | 0.38164    | 0.38164    |   0.0 |  1.20
Other   |            | 0.06538    |            |       |  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.7958 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.717 ns/day, 8.832 hours/ns, 31.451 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.216     | 31.216     | 31.216     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12888    | 0.12888    | 0.12888    |   0.0 |  0.41
Output  | 0.00015339 | 0.00015339 | 0.00015339 |   0.0 |  0.00
Modify  | 0.38554    | 0.38554    | 0.38554    |   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:        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.5825 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.736 ns/day, 8.773 hours/ns, 31.663 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.01      | 31.01      | 31.01      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12669    | 0.12669    | 0.12669    |   0.0 |  0.40
Output  | 0.00015593 | 0.00015593 | 0.00015593 |   0.0 |  0.00
Modify  | 0.37874    | 0.37874    | 0.37874    |   0.0 |  1.20
Other   |            | 0.06656    |            |       |  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 31.6976 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.726 ns/day, 8.805 hours/ns, 31.548 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.118     | 31.118     | 31.118     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12793    | 0.12793    | 0.12793    |   0.0 |  0.40
Output  | 0.00015437 | 0.00015437 | 0.00015437 |   0.0 |  0.00
Modify  | 0.38584    | 0.38584    | 0.38584    |   0.0 |  1.22
Other   |            | 0.06571    |            |       |  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.3963 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.752 ns/day, 8.721 hours/ns, 31.851 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.825     | 30.825     | 30.825     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12788    | 0.12788    | 0.12788    |   0.0 |  0.41
Output  | 0.00015507 | 0.00015507 | 0.00015507 |   0.0 |  0.00
Modify  | 0.37908    | 0.37908    | 0.37908    |   0.0 |  1.21
Other   |            | 0.06455    |            |       |  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