# 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 4.044650763273239*${_u_distance}
variable latticeconst_converted equal 4.044650763273239*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04465076327324
Lattice spacing in x,y,z = 4.0446508 4.0446508 4.0446508
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 (40.446508 40.446508 40.446508)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (40.446508 40.446508 40.446508)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JeongParkDo_2018_PdAl__MO_616482358807_001
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13278.129   -13278.129       -13440       -13440       313.15       313.15     66167.25     66167.25    2613.0383    2613.0383 
    1000   -13097.991   -13097.991   -13268.486   -13268.486    329.83489    329.83489    67538.025    67538.025   -687.97591   -687.97591 
Loop time of 366.274 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.743 hours/ns, 2.730 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    | 365.26     | 365.26     | 365.26     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15774    | 0.15774    | 0.15774    |   0.0 |  0.04
Output  | 0.00032241 | 0.00032241 | 0.00032241 |   0.0 |  0.00
Modify  | 0.75231    | 0.75231    | 0.75231    |   0.0 |  0.21
Other   |            | 0.103      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312000.0 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13097.991   -13097.991   -13268.486   -13268.486    329.83489    329.83489    67538.025    67538.025   -687.97591   -687.97591 
    2000   -13115.993   -13115.993    -13275.38    -13275.38    308.34333    308.34333    67450.673    67450.673    -366.4911    -366.4911 
Loop time of 383.083 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.412 hours/ns, 2.610 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    | 382.02     | 382.02     | 382.02     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16244    | 0.16244    | 0.16244    |   0.0 |  0.04
Output  | 0.00025684 | 0.00025684 | 0.00025684 |   0.0 |  0.00
Modify  | 0.79419    | 0.79419    | 0.79419    |   0.0 |  0.21
Other   |            | 0.1066     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279992.0 ave      279992 max      279992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279992
Ave neighs/atom = 69.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13115.993   -13115.993    -13275.38    -13275.38    308.34333    308.34333    67450.673    67450.673    -366.4911    -366.4911 
    3000    -13103.76    -13103.76   -13261.858   -13261.858     305.8528     305.8528    67429.905    67429.905      753.216      753.216 
Loop time of 357.819 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.241 ns/day, 99.394 hours/ns, 2.795 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    | 356.85     | 356.85     | 356.85     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15266    | 0.15266    | 0.15266    |   0.0 |  0.04
Output  | 0.00021045 | 0.00021045 | 0.00021045 |   0.0 |  0.00
Modify  | 0.71514    | 0.71514    | 0.71514    |   0.0 |  0.20
Other   |            | 0.1022     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281168.0 ave      281168 max      281168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281168
Ave neighs/atom = 70.292000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000    -13103.76    -13103.76   -13261.858   -13261.858     305.8528     305.8528    67429.905    67429.905      753.216      753.216 
    4000   -13113.015   -13113.015   -13271.106   -13271.106    305.83726    305.83726    67428.263    67428.263    98.606158    98.606158 
Loop time of 349.199 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.247 ns/day, 97.000 hours/ns, 2.864 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    | 348.25     | 348.25     | 348.25     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15128    | 0.15128    | 0.15128    |   0.0 |  0.04
Output  | 0.00021824 | 0.00021824 | 0.00021824 |   0.0 |  0.00
Modify  | 0.69433    | 0.69433    | 0.69433    |   0.0 |  0.20
Other   |            | 0.09919    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280364.0 ave      280364 max      280364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280364
Ave neighs/atom = 70.091000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13113.015   -13113.015   -13271.106   -13271.106    305.83726    305.83726    67428.263    67428.263    98.606158    98.606158 
    5000   -13107.959   -13107.959   -13267.672   -13267.672    308.97666    308.97666    67512.262    67512.262   -544.36757   -544.36757 
Loop time of 332.981 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.259 ns/day, 92.495 hours/ns, 3.003 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    | 332.1      | 332.1      | 332.1      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14464    | 0.14464    | 0.14464    |   0.0 |  0.04
Output  | 0.00017871 | 0.00017871 | 0.00017871 |   0.0 |  0.00
Modify  | 0.64371    | 0.64371    | 0.64371    |   0.0 |  0.19
Other   |            | 0.09442    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281108.0 ave      281108 max      281108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281108
Ave neighs/atom = 70.277000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 317.169622854799, Press = -181.816713504952
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13107.959   -13107.959   -13267.672   -13267.672    308.97666    308.97666    67512.262    67512.262   -544.36757   -544.36757 
    6000   -13108.826   -13108.826   -13270.875   -13270.875     313.4946     313.4946    67452.395    67452.395   -53.123463   -53.123463 
Loop time of 330.773 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.881 hours/ns, 3.023 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    | 329.87     | 329.87     | 329.87     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14498    | 0.14498    | 0.14498    |   0.0 |  0.04
Output  | 0.00022208 | 0.00022208 | 0.00022208 |   0.0 |  0.00
Modify  | 0.66057    | 0.66057    | 0.66057    |   0.0 |  0.20
Other   |            | 0.09299    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280006.0 ave      280006 max      280006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280006
Ave neighs/atom = 70.001500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.763211016017, Press = 31.4368864893502
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13108.826   -13108.826   -13270.875   -13270.875     313.4946     313.4946    67452.395    67452.395   -53.123463   -53.123463 
    7000   -13109.949   -13109.949   -13273.083   -13273.083    315.59343    315.59343    67301.572    67301.572     1527.049     1527.049 
Loop time of 365.838 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.622 hours/ns, 2.733 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    | 364.81     | 364.81     | 364.81     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15779    | 0.15779    | 0.15779    |   0.0 |  0.04
Output  | 0.00017969 | 0.00017969 | 0.00017969 |   0.0 |  0.00
Modify  | 0.76673    | 0.76673    | 0.76673    |   0.0 |  0.21
Other   |            | 0.1031     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280940.0 ave      280940 max      280940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280940
Ave neighs/atom = 70.235000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.18049439272, Press = -9.89316074441794
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13109.949   -13109.949   -13273.083   -13273.083    315.59343    315.59343    67301.572    67301.572     1527.049     1527.049 
    8000   -13108.831   -13108.831   -13270.897   -13270.897    313.52766    313.52766    67489.367    67489.367   -524.51015   -524.51015 
Loop time of 387.509 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.641 hours/ns, 2.581 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    | 386.4      | 386.4      | 386.4      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16454    | 0.16454    | 0.16454    |   0.0 |  0.04
Output  | 0.00022792 | 0.00022792 | 0.00022792 |   0.0 |  0.00
Modify  | 0.83356    | 0.83356    | 0.83356    |   0.0 |  0.22
Other   |            | 0.1093     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282348.0 ave      282348 max      282348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282348
Ave neighs/atom = 70.587000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.849929998269, Press = -10.4067097606811
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13108.831   -13108.831   -13270.897   -13270.897    313.52766    313.52766    67489.367    67489.367   -524.51015   -524.51015 
    9000   -13112.398   -13112.398   -13275.573   -13275.573    315.67285    315.67285    67477.542    67477.542   -654.80348   -654.80348 
Loop time of 379.198 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.333 hours/ns, 2.637 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    | 378.12     | 378.12     | 378.12     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16197    | 0.16197    | 0.16197    |   0.0 |  0.04
Output  | 0.00018422 | 0.00018422 | 0.00018422 |   0.0 |  0.00
Modify  | 0.80752    | 0.80752    | 0.80752    |   0.0 |  0.21
Other   |            | 0.1052     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280292.0 ave      280292 max      280292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280292
Ave neighs/atom = 70.073000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.65259327132, Press = 0.961911702300892
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13112.398   -13112.398   -13275.573   -13275.573    315.67285    315.67285    67477.542    67477.542   -654.80348   -654.80348 
   10000   -13111.653   -13111.653    -13272.55    -13272.55    311.26628    311.26628    67427.406    67427.406    11.651868    11.651868 
Loop time of 371.134 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 103.093 hours/ns, 2.694 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    | 370.08     | 370.08     | 370.08     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1593     | 0.1593     | 0.1593     |   0.0 |  0.04
Output  | 0.00025548 | 0.00025548 | 0.00025548 |   0.0 |  0.00
Modify  | 0.78881    | 0.78881    | 0.78881    |   0.0 |  0.21
Other   |            | 0.1044     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280790.0 ave      280790 max      280790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280790
Ave neighs/atom = 70.197500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.240850587894, Press = -0.204497417249603
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13111.653   -13111.653    -13272.55    -13272.55    311.26628    311.26628    67427.406    67427.406    11.651868    11.651868 
   11000   -13107.158   -13107.158    -13272.19    -13272.19    319.26724    319.26724    67425.777    67425.777    187.51138    187.51138 
Loop time of 383.914 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.643 hours/ns, 2.605 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 382.82     | 382.82     | 382.82     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16455    | 0.16455    | 0.16455    |   0.0 |  0.04
Output  | 0.00021565 | 0.00021565 | 0.00021565 |   0.0 |  0.00
Modify  | 0.82548    | 0.82548    | 0.82548    |   0.0 |  0.22
Other   |            | 0.1066     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281074.0 ave      281074 max      281074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281074
Ave neighs/atom = 70.268500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.467190846823, Press = -2.30804017845866
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13107.158   -13107.158    -13272.19    -13272.19    319.26724    319.26724    67425.777    67425.777    187.51138    187.51138 
   12000   -13105.087   -13105.087   -13268.739   -13268.739    316.59472    316.59472    67486.586    67486.586   -274.78128   -274.78128 
Loop time of 372.35 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.431 hours/ns, 2.686 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    | 371.3      | 371.3      | 371.3      |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16016    | 0.16016    | 0.16016    |   0.0 |  0.04
Output  | 0.00029429 | 0.00029429 | 0.00029429 |   0.0 |  0.00
Modify  | 0.78692    | 0.78692    | 0.78692    |   0.0 |  0.21
Other   |            | 0.1033     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281244.0 ave      281244 max      281244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281244
Ave neighs/atom = 70.311000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.58836747543, Press = -6.05839558142499
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13105.087   -13105.087   -13268.739   -13268.739    316.59472    316.59472    67486.586    67486.586   -274.78128   -274.78128 
   13000   -13113.971   -13113.971   -13273.924   -13273.924       309.44       309.44    67538.939    67538.939   -1308.3928   -1308.3928 
Loop time of 347.735 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.248 ns/day, 96.593 hours/ns, 2.876 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    | 346.77     | 346.77     | 346.77     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15197    | 0.15197    | 0.15197    |   0.0 |  0.04
Output  | 0.00018024 | 0.00018024 | 0.00018024 |   0.0 |  0.00
Modify  | 0.7111     | 0.7111     | 0.7111     |   0.0 |  0.20
Other   |            | 0.09869    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280668.0 ave      280668 max      280668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280668
Ave neighs/atom = 70.167000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.815194404211, Press = 2.49436365282602
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13113.971   -13113.971   -13273.924   -13273.924       309.44       309.44    67538.939    67538.939   -1308.3928   -1308.3928 
   14000   -13106.428   -13106.428   -13272.066   -13272.066    320.43819    320.43819    67379.407    67379.407    691.75828    691.75828 
Loop time of 331.65 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 92.125 hours/ns, 3.015 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    | 330.75     | 330.75     | 330.75     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14591    | 0.14591    | 0.14591    |   0.0 |  0.04
Output  | 0.00018746 | 0.00018746 | 0.00018746 |   0.0 |  0.00
Modify  | 0.66301    | 0.66301    | 0.66301    |   0.0 |  0.20
Other   |            | 0.0955     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280316.0 ave      280316 max      280316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280316
Ave neighs/atom = 70.079000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.725659359659, Press = 1.63823366272917
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13106.428   -13106.428   -13272.066   -13272.066    320.43819    320.43819    67379.407    67379.407    691.75828    691.75828 
   15000   -13110.396   -13110.396   -13273.841   -13273.841    316.19651    316.19651     67437.59     67437.59   -112.98706   -112.98706 
Loop time of 334.974 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 93.048 hours/ns, 2.985 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    | 334.06     | 334.06     | 334.06     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14765    | 0.14765    | 0.14765    |   0.0 |  0.04
Output  | 0.00051981 | 0.00051981 | 0.00051981 |   0.0 |  0.00
Modify  | 0.67021    | 0.67021    | 0.67021    |   0.0 |  0.20
Other   |            | 0.09538    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5835.00 ave        5835 max        5835 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281354.0 ave      281354 max      281354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281354
Ave neighs/atom = 70.338500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.598892427227, Press = -3.42447560023938
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13110.396   -13110.396   -13273.841   -13273.841    316.19651    316.19651     67437.59     67437.59   -112.98706   -112.98706 
   16000   -13105.242   -13105.242   -13267.781   -13267.781    314.44278    314.44278    67553.967    67553.967   -976.83205   -976.83205 
Loop time of 367.5 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.083 hours/ns, 2.721 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    | 366.46     | 366.46     | 366.46     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15868    | 0.15868    | 0.15868    |   0.0 |  0.04
Output  | 0.00018373 | 0.00018373 | 0.00018373 |   0.0 |  0.00
Modify  | 0.77793    | 0.77793    | 0.77793    |   0.0 |  0.21
Other   |            | 0.1036     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281052.0 ave      281052 max      281052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281052
Ave neighs/atom = 70.263000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.625369376058, Press = -0.911787247055735
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13105.242   -13105.242   -13267.781   -13267.781    314.44278    314.44278    67553.967    67553.967   -976.83205   -976.83205 
   17000   -13111.826   -13111.826   -13270.378   -13270.378    306.72917    306.72917    67437.411    67437.411    81.751255    81.751255 
Loop time of 376.533 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.592 hours/ns, 2.656 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    | 375.46     | 375.46     | 375.46     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16086    | 0.16086    | 0.16086    |   0.0 |  0.04
Output  | 0.00018215 | 0.00018215 | 0.00018215 |   0.0 |  0.00
Modify  | 0.80187    | 0.80187    | 0.80187    |   0.0 |  0.21
Other   |            | 0.1061     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279754.0 ave      279754 max      279754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279754
Ave neighs/atom = 69.938500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.577788005967, Press = 3.14442216425156
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13111.826   -13111.826   -13270.378   -13270.378    306.72917    306.72917    67437.411    67437.411    81.751255    81.751255 
   18000   -13106.864   -13106.864   -13271.432   -13271.432    318.36751    318.36751    67366.514    67366.514    928.28207    928.28207 
Loop time of 377.632 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.898 hours/ns, 2.648 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    | 376.56     | 376.56     | 376.56     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16157    | 0.16157    | 0.16157    |   0.0 |  0.04
Output  | 0.00023464 | 0.00023464 | 0.00023464 |   0.0 |  0.00
Modify  | 0.80594    | 0.80594    | 0.80594    |   0.0 |  0.21
Other   |            | 0.1059     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280978.0 ave      280978 max      280978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280978
Ave neighs/atom = 70.244500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.500155343949, Press = -1.20682096815807
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13106.864   -13106.864   -13271.432   -13271.432    318.36751    318.36751    67366.514    67366.514    928.28207    928.28207 
   19000   -13113.181   -13113.181    -13274.23    -13274.23    311.56084    311.56084    67475.912    67475.912    -618.3261    -618.3261 
Loop time of 356.021 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.243 ns/day, 98.895 hours/ns, 2.809 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 355.02     | 355.02     | 355.02     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15525    | 0.15525    | 0.15525    |   0.0 |  0.04
Output  | 0.00017953 | 0.00017953 | 0.00017953 |   0.0 |  0.00
Modify  | 0.74084    | 0.74084    | 0.74084    |   0.0 |  0.21
Other   |            | 0.09985    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281434.0 ave      281434 max      281434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281434
Ave neighs/atom = 70.358500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.510756143418, Press = -2.64448055720013
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13113.181   -13113.181    -13274.23    -13274.23    311.56084    311.56084    67475.912    67475.912    -618.3261    -618.3261 
   20000    -13105.65    -13105.65   -13270.216   -13270.216    318.36322    318.36322    67512.971    67512.971   -620.97845   -620.97845 
Loop time of 365.16 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.433 hours/ns, 2.739 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    | 364.14     | 364.14     | 364.14     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15782    | 0.15782    | 0.15782    |   0.0 |  0.04
Output  | 0.00029748 | 0.00029748 | 0.00029748 |   0.0 |  0.00
Modify  | 0.75854    | 0.75854    | 0.75854    |   0.0 |  0.21
Other   |            | 0.1018     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280840.0 ave      280840 max      280840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280840
Ave neighs/atom = 70.210000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.471159380483, Press = 0.487363215434833
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000    -13105.65    -13105.65   -13270.216   -13270.216    318.36322    318.36322    67512.971    67512.971   -620.97845   -620.97845 
   21000   -13112.297   -13112.297   -13271.105   -13271.105    307.22483    307.22483    67400.138    67400.138    431.49009    431.49009 
Loop time of 363.002 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.834 hours/ns, 2.755 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    | 361.98     | 361.98     | 361.98     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15557    | 0.15557    | 0.15557    |   0.0 |  0.04
Output  | 0.00021866 | 0.00021866 | 0.00021866 |   0.0 |  0.00
Modify  | 0.76056    | 0.76056    | 0.76056    |   0.0 |  0.21
Other   |            | 0.1028     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280368.0 ave      280368 max      280368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280368
Ave neighs/atom = 70.092000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.47956900782, Press = 0.592714997405557
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13112.297   -13112.297   -13271.105   -13271.105    307.22483    307.22483    67400.138    67400.138    431.49009    431.49009 
   22000   -13110.606   -13110.606   -13273.689   -13273.689    315.49566    315.49566     67396.62     67396.62     436.7284     436.7284 
Loop time of 357.562 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.242 ns/day, 99.323 hours/ns, 2.797 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    | 356.57     | 356.57     | 356.57     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15419    | 0.15419    | 0.15419    |   0.0 |  0.04
Output  | 0.00022373 | 0.00022373 | 0.00022373 |   0.0 |  0.00
Modify  | 0.7407     | 0.7407     | 0.7407     |   0.0 |  0.21
Other   |            | 0.1003     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281356.0 ave      281356 max      281356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281356
Ave neighs/atom = 70.339000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.60497088829, Press = -1.65489721775923
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13110.606   -13110.606   -13273.689   -13273.689    315.49566    315.49566     67396.62     67396.62     436.7284     436.7284 
   23000   -13104.442   -13104.442   -13267.309   -13267.309    315.07672    315.07672    67610.172    67610.172   -1582.3494   -1582.3494 
Loop time of 357.075 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.242 ns/day, 99.187 hours/ns, 2.801 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 356.08     | 356.08     | 356.08     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15389    | 0.15389    | 0.15389    |   0.0 |  0.04
Output  | 0.0002324  | 0.0002324  | 0.0002324  |   0.0 |  0.00
Modify  | 0.74307    | 0.74307    | 0.74307    |   0.0 |  0.21
Other   |            | 0.1008     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281418.0 ave      281418 max      281418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281418
Ave neighs/atom = 70.354500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.739992782348, Press = -1.8039375156013
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13104.442   -13104.442   -13267.309   -13267.309    315.07672    315.07672    67610.172    67610.172   -1582.3494   -1582.3494 
   24000    -13110.51    -13110.51   -13272.181   -13272.181    312.76482    312.76482    67426.714    67426.714    117.61024    117.61024 
Loop time of 382.197 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.166 hours/ns, 2.616 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 381.11     | 381.11     | 381.11     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16218    | 0.16218    | 0.16218    |   0.0 |  0.04
Output  | 0.00018013 | 0.00018013 | 0.00018013 |   0.0 |  0.00
Modify  | 0.8185     | 0.8185     | 0.8185     |   0.0 |  0.21
Other   |            | 0.1066     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279400.0 ave      279400 max      279400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279400
Ave neighs/atom = 69.850000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.827037622547, Press = 2.45927977680032
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000    -13110.51    -13110.51   -13272.181   -13272.181    312.76482    312.76482    67426.714    67426.714    117.61024    117.61024 
   25000   -13102.787   -13102.787   -13267.388   -13267.388    318.43249    318.43249     67409.26     67409.26    806.05142    806.05142 
Loop time of 384.11 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.697 hours/ns, 2.603 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    | 383.01     | 383.01     | 383.01     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16439    | 0.16439    | 0.16439    |   0.0 |  0.04
Output  | 0.00017736 | 0.00017736 | 0.00017736 |   0.0 |  0.00
Modify  | 0.82912    | 0.82912    | 0.82912    |   0.0 |  0.22
Other   |            | 0.1072     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281232.0 ave      281232 max      281232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281232
Ave neighs/atom = 70.308000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.906516843634, Press = -0.544351696611165
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13102.787   -13102.787   -13267.388   -13267.388    318.43249    318.43249     67409.26     67409.26    806.05142    806.05142 
   26000   -13108.799   -13108.799   -13270.157   -13270.157    312.15844    312.15844    67472.121    67472.121   -249.79928   -249.79928 
Loop time of 376.476 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.577 hours/ns, 2.656 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    | 375.41     | 375.41     | 375.41     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16118    | 0.16118    | 0.16118    |   0.0 |  0.04
Output  | 0.00017939 | 0.00017939 | 0.00017939 |   0.0 |  0.00
Modify  | 0.80397    | 0.80397    | 0.80397    |   0.0 |  0.21
Other   |            | 0.1046     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281144.0 ave      281144 max      281144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281144
Ave neighs/atom = 70.286000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.938204524093, Press = -1.40074425311788
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13108.799   -13108.799   -13270.157   -13270.157    312.15844    312.15844    67472.121    67472.121   -249.79928   -249.79928 
   27000   -13107.278   -13107.278   -13268.531   -13268.531    311.95442    311.95442    67515.447    67515.447   -626.79493   -626.79493 
Loop time of 378.903 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.251 hours/ns, 2.639 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    | 377.83     | 377.83     | 377.83     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16144    | 0.16144    | 0.16144    |   0.0 |  0.04
Output  | 0.00021674 | 0.00021674 | 0.00021674 |   0.0 |  0.00
Modify  | 0.80962    | 0.80962    | 0.80962    |   0.0 |  0.21
Other   |            | 0.1063     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280532.0 ave      280532 max      280532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280532
Ave neighs/atom = 70.133000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.940164767092, Press = 0.305735179276129
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13107.278   -13107.278   -13268.531   -13268.531    311.95442    311.95442    67515.447    67515.447   -626.79493   -626.79493 
   28000   -13113.947   -13113.947   -13274.168   -13274.168    309.95767    309.95767    67356.989    67356.989    709.99739    709.99739 
Loop time of 380.424 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.673 hours/ns, 2.629 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    | 379.34     | 379.34     | 379.34     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16311    | 0.16311    | 0.16311    |   0.0 |  0.04
Output  | 0.00028633 | 0.00028633 | 0.00028633 |   0.0 |  0.00
Modify  | 0.81432    | 0.81432    | 0.81432    |   0.0 |  0.21
Other   |            | 0.106      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280536.0 ave      280536 max      280536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280536
Ave neighs/atom = 70.134000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.85042960409, Press = 0.841624713128396
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13113.947   -13113.947   -13274.168   -13274.168    309.95767    309.95767    67356.989    67356.989    709.99739    709.99739 
   29000   -13106.785   -13106.785   -13267.381   -13267.381    310.68282    310.68282    67363.393    67363.393    1166.2361    1166.2361 
Loop time of 385.735 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.149 hours/ns, 2.592 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    | 384.63     | 384.63     | 384.63     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1636     | 0.1636     | 0.1636     |   0.0 |  0.04
Output  | 0.00017958 | 0.00017958 | 0.00017958 |   0.0 |  0.00
Modify  | 0.83058    | 0.83058    | 0.83058    |   0.0 |  0.22
Other   |            | 0.107      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281756.0 ave      281756 max      281756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281756
Ave neighs/atom = 70.439000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.848473997879, Press = -2.68459337539773
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13106.785   -13106.785   -13267.381   -13267.381    310.68282    310.68282    67363.393    67363.393    1166.2361    1166.2361 
   30000   -13110.612   -13110.612    -13273.33    -13273.33    314.78873    314.78873    67557.422    67557.422   -1370.6548   -1370.6548 
Loop time of 389 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.055 hours/ns, 2.571 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    | 387.89     | 387.89     | 387.89     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16582    | 0.16582    | 0.16582    |   0.0 |  0.04
Output  | 0.00018358 | 0.00018358 | 0.00018358 |   0.0 |  0.00
Modify  | 0.83365    | 0.83365    | 0.83365    |   0.0 |  0.21
Other   |            | 0.1074     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281530.0 ave      281530 max      281530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281530
Ave neighs/atom = 70.382500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.860550208175, Press = -0.754144779184034
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13110.612   -13110.612    -13273.33    -13273.33    314.78873    314.78873    67557.422    67557.422   -1370.6548   -1370.6548 
   31000   -13106.449   -13106.449   -13269.813   -13269.813    316.03834    316.03834     67457.15     67457.15   -19.906603   -19.906603 
Loop time of 351.925 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.246 ns/day, 97.757 hours/ns, 2.842 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    | 350.95     | 350.95     | 350.95     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1513     | 0.1513     | 0.1513     |   0.0 |  0.04
Output  | 0.00018115 | 0.00018115 | 0.00018115 |   0.0 |  0.00
Modify  | 0.72625    | 0.72625    | 0.72625    |   0.0 |  0.21
Other   |            | 0.09979    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280162.0 ave      280162 max      280162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280162
Ave neighs/atom = 70.040500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.871652524434, Press = 0.60363364690832
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13106.449   -13106.449   -13269.813   -13269.813    316.03834    316.03834     67457.15     67457.15   -19.906603   -19.906603 
   32000   -13105.736   -13105.736   -13269.322   -13269.322    316.46835    316.46835    67416.906    67416.906    524.06747    524.06747 
Loop time of 351.37 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.246 ns/day, 97.603 hours/ns, 2.846 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    | 350.39     | 350.39     | 350.39     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15153    | 0.15153    | 0.15153    |   0.0 |  0.04
Output  | 0.0001831  | 0.0001831  | 0.0001831  |   0.0 |  0.00
Modify  | 0.7273     | 0.7273     | 0.7273     |   0.0 |  0.21
Other   |            | 0.1001     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280984.0 ave      280984 max      280984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280984
Ave neighs/atom = 70.246000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
67446.3733945866

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0