# 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 3.520000003278256*${_u_distance}
variable latticeconst_converted equal 3.520000003278256*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52000000327826
Lattice spacing in x,y,z = 3.5200000 3.5200000 3.5200000
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 (35.200000 35.200000 35.200000)
  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 (35.200000 35.200000 35.200000)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_Wagner_2007_Ni__MO_444394830472_001
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43614.2081218568 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_444394830472_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17648.467   -17648.467       -17800       -17800       293.15       293.15    43614.208    43614.208     3711.034     3711.034 
    1000   -17485.853   -17485.853    -17638.34    -17638.34    294.99658    294.99658     43916.26     43916.26    2607.2445    2607.2445 
Loop time of 188.672 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.458 ns/day, 52.409 hours/ns, 5.300 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 187.74     | 187.74     | 187.74     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15135    | 0.15135    | 0.15135    |   0.0 |  0.08
Output  | 0.00022469 | 0.00022469 | 0.00022469 |   0.0 |  0.00
Modify  | 0.68419    | 0.68419    | 0.68419    |   0.0 |  0.36
Other   |            | 0.09843    |            |       |  0.05

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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -17485.853   -17485.853    -17638.34    -17638.34    294.99658    294.99658     43916.26     43916.26    2607.2445    2607.2445 
    2000    -17491.43    -17491.43   -17642.065   -17642.065    291.41371    291.41371    43945.206    43945.206    1060.2476    1060.2476 
Loop time of 199.903 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.529 hours/ns, 5.002 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    | 198.98     | 198.98     | 198.98     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14819    | 0.14819    | 0.14819    |   0.0 |  0.07
Output  | 0.00022277 | 0.00022277 | 0.00022277 |   0.0 |  0.00
Modify  | 0.6753     | 0.6753     | 0.6753     |   0.0 |  0.34
Other   |            | 0.0984     |            |       |  0.05

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:      314950.0 ave      314950 max      314950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314950
Ave neighs/atom = 78.737500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -17491.43    -17491.43   -17642.065   -17642.065    291.41371    291.41371    43945.206    43945.206    1060.2476    1060.2476 
    3000   -17494.778   -17494.778   -17645.929   -17645.929    292.41065    292.41065     43953.73     43953.73    545.40377    545.40377 
Loop time of 201.452 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.959 hours/ns, 4.964 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    | 200.53     | 200.53     | 200.53     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1493     | 0.1493     | 0.1493     |   0.0 |  0.07
Output  | 0.00021481 | 0.00021481 | 0.00021481 |   0.0 |  0.00
Modify  | 0.67853    | 0.67853    | 0.67853    |   0.0 |  0.34
Other   |            | 0.09891    |            |       |  0.05

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:      314790.0 ave      314790 max      314790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314790
Ave neighs/atom = 78.697500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17494.778   -17494.778   -17645.929   -17645.929    292.41065    292.41065     43953.73     43953.73    545.40377    545.40377 
    4000   -17487.856   -17487.856   -17642.602   -17642.602    299.36639    299.36639    43958.466    43958.466    643.31933    643.31933 
Loop time of 199.742 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.484 hours/ns, 5.006 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    | 198.83     | 198.83     | 198.83     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14686    | 0.14686    | 0.14686    |   0.0 |  0.07
Output  | 0.00021262 | 0.00021262 | 0.00021262 |   0.0 |  0.00
Modify  | 0.67183    | 0.67183    | 0.67183    |   0.0 |  0.34
Other   |            | 0.09841    |            |       |  0.05

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:      314570.0 ave      314570 max      314570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314570
Ave neighs/atom = 78.642500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -17487.856   -17487.856   -17642.602   -17642.602    299.36639    299.36639    43958.466    43958.466    643.31933    643.31933 
    5000    -17495.89    -17495.89   -17645.141   -17645.141    288.73628    288.73628    43938.559    43938.559    1126.2138    1126.2138 
Loop time of 200.142 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.595 hours/ns, 4.996 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    | 199.21     | 199.21     | 199.21     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14897    | 0.14897    | 0.14897    |   0.0 |  0.07
Output  | 0.00017486 | 0.00017486 | 0.00017486 |   0.0 |  0.00
Modify  | 0.6803     | 0.6803     | 0.6803     |   0.0 |  0.34
Other   |            | 0.09931    |            |       |  0.05

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:      314766.0 ave      314766 max      314766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314766
Ave neighs/atom = 78.691500
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 = 289.995443849686, Press = 136.614236024271
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000    -17495.89    -17495.89   -17645.141   -17645.141    288.73628    288.73628    43938.559    43938.559    1126.2138    1126.2138 
    6000   -17492.172   -17492.172   -17642.526   -17642.526    290.87064    290.87064    43905.894    43905.894    2556.0707    2556.0707 
Loop time of 199.082 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.300 hours/ns, 5.023 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    | 198.14     | 198.14     | 198.14     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14839    | 0.14839    | 0.14839    |   0.0 |  0.07
Output  | 0.00017533 | 0.00017533 | 0.00017533 |   0.0 |  0.00
Modify  | 0.69544    | 0.69544    | 0.69544    |   0.0 |  0.35
Other   |            | 0.09856    |            |       |  0.05

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:      314884.0 ave      314884 max      314884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314884
Ave neighs/atom = 78.721000
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.338185220588, Press = 12.6144376899197
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -17492.172   -17492.172   -17642.526   -17642.526    290.87064    290.87064    43905.894    43905.894    2556.0707    2556.0707 
    7000   -17489.256   -17489.256   -17639.829   -17639.829    291.29474    291.29474    43920.393    43920.393    2130.4303    2130.4303 
Loop time of 199.007 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.280 hours/ns, 5.025 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.06     | 198.06     | 198.06     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14841    | 0.14841    | 0.14841    |   0.0 |  0.07
Output  | 0.0001785  | 0.0001785  | 0.0001785  |   0.0 |  0.00
Modify  | 0.69696    | 0.69696    | 0.69696    |   0.0 |  0.35
Other   |            | 0.09784    |            |       |  0.05

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:      314950.0 ave      314950 max      314950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314950
Ave neighs/atom = 78.737500
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.959546424701, Press = 13.2841128973529
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -17489.256   -17489.256   -17639.829   -17639.829    291.29474    291.29474    43920.393    43920.393    2130.4303    2130.4303 
    8000   -17494.671   -17494.671   -17645.035   -17645.035    290.88971    290.88971    43937.508    43937.508    1105.5953    1105.5953 
Loop time of 199.975 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.549 hours/ns, 5.001 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    | 199.03     | 199.03     | 199.03     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14963    | 0.14963    | 0.14963    |   0.0 |  0.07
Output  | 0.00021621 | 0.00021621 | 0.00021621 |   0.0 |  0.00
Modify  | 0.69673    | 0.69673    | 0.69673    |   0.0 |  0.35
Other   |            | 0.09864    |            |       |  0.05

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:      315054.0 ave      315054 max      315054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315054
Ave neighs/atom = 78.763500
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.023088694357, Press = 6.17445452505577
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17494.671   -17494.671   -17645.035   -17645.035    290.88971    290.88971    43937.508    43937.508    1105.5953    1105.5953 
    9000    -17491.71    -17491.71   -17644.188   -17644.188    294.97872    294.97872     43955.66     43955.66    612.11129    612.11129 
Loop time of 199.693 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.470 hours/ns, 5.008 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.74     | 198.74     | 198.74     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14916    | 0.14916    | 0.14916    |   0.0 |  0.07
Output  | 0.0002475  | 0.0002475  | 0.0002475  |   0.0 |  0.00
Modify  | 0.70286    | 0.70286    | 0.70286    |   0.0 |  0.35
Other   |            | 0.09853    |            |       |  0.05

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:      314852.0 ave      314852 max      314852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314852
Ave neighs/atom = 78.713000
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.890294675709, Press = 0.928354422622483
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000    -17491.71    -17491.71   -17644.188   -17644.188    294.97872    294.97872     43955.66     43955.66    612.11129    612.11129 
   10000   -17497.665   -17497.665   -17648.085   -17648.085    290.99709    290.99709    43946.526    43946.526    647.76004    647.76004 
Loop time of 200.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.624 hours/ns, 4.994 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    | 199.3      | 199.3      | 199.3      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1495     | 0.1495     | 0.1495     |   0.0 |  0.07
Output  | 0.00017418 | 0.00017418 | 0.00017418 |   0.0 |  0.00
Modify  | 0.70113    | 0.70113    | 0.70113    |   0.0 |  0.35
Other   |            | 0.09854    |            |       |  0.05

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:      314796.0 ave      314796 max      314796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314796
Ave neighs/atom = 78.699000
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.771140741349, Press = 0.360011064307478
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17497.665   -17497.665   -17648.085   -17648.085    290.99709    290.99709    43946.526    43946.526    647.76004    647.76004 
   11000   -17490.946   -17490.946   -17643.234   -17643.234    294.61196    294.61196    43952.674    43952.674    788.46195    788.46195 
Loop time of 201.277 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.910 hours/ns, 4.968 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    | 200.33     | 200.33     | 200.33     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14845    | 0.14845    | 0.14845    |   0.0 |  0.07
Output  | 0.00017854 | 0.00017854 | 0.00017854 |   0.0 |  0.00
Modify  | 0.70506    | 0.70506    | 0.70506    |   0.0 |  0.35
Other   |            | 0.09797    |            |       |  0.05

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:      314790.0 ave      314790 max      314790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314790
Ave neighs/atom = 78.697500
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.607891470116, Press = 1.6838572285672
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -17490.946   -17490.946   -17643.234   -17643.234    294.61196    294.61196    43952.674    43952.674    788.46195    788.46195 
   12000   -17493.107   -17493.107   -17644.904   -17644.904    293.66083    293.66083    43950.392    43950.392    774.34262    774.34262 
Loop time of 201.836 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.066 hours/ns, 4.955 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    | 200.88     | 200.88     | 200.88     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14972    | 0.14972    | 0.14972    |   0.0 |  0.07
Output  | 0.00017976 | 0.00017976 | 0.00017976 |   0.0 |  0.00
Modify  | 0.71175    | 0.71175    | 0.71175    |   0.0 |  0.35
Other   |            | 0.09953    |            |       |  0.05

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:      314916.0 ave      314916 max      314916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314916
Ave neighs/atom = 78.729000
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.653190079027, Press = 2.95333006389854
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17493.107   -17493.107   -17644.904   -17644.904    293.66083    293.66083    43950.392    43950.392    774.34262    774.34262 
   13000   -17493.564   -17493.564   -17644.528   -17644.528     292.0514     292.0514    43956.805    43956.805    498.80146    498.80146 
Loop time of 198.955 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.265 hours/ns, 5.026 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    | 198.01     | 198.01     | 198.01     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14783    | 0.14783    | 0.14783    |   0.0 |  0.07
Output  | 0.0001763  | 0.0001763  | 0.0001763  |   0.0 |  0.00
Modify  | 0.69925    | 0.69925    | 0.69925    |   0.0 |  0.35
Other   |            | 0.09812    |            |       |  0.05

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:      314788.0 ave      314788 max      314788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314788
Ave neighs/atom = 78.697000
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.901945164779, Press = 5.68942647793614
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -17493.564   -17493.564   -17644.528   -17644.528     292.0514     292.0514    43956.805    43956.805    498.80146    498.80146 
   14000   -17489.194   -17489.194   -17642.235   -17642.235    296.06796    296.06796    43967.537    43967.537    257.48278    257.48278 
Loop time of 201.296 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.916 hours/ns, 4.968 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    | 200.35     | 200.35     | 200.35     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14904    | 0.14904    | 0.14904    |   0.0 |  0.07
Output  | 0.000278   | 0.000278   | 0.000278   |   0.0 |  0.00
Modify  | 0.69873    | 0.69873    | 0.69873    |   0.0 |  0.35
Other   |            | 0.09791    |            |       |  0.05

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:      314850.0 ave      314850 max      314850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314850
Ave neighs/atom = 78.712500
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.077094259397, Press = 6.61360851693897
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -17489.194   -17489.194   -17642.235   -17642.235    296.06796    296.06796    43967.537    43967.537    257.48278    257.48278 
   15000   -17493.291   -17493.291   -17644.589   -17644.589    292.69671    292.69671    43974.224    43974.224   -165.29371   -165.29371 
Loop time of 199.05 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.292 hours/ns, 5.024 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    | 198.11     | 198.11     | 198.11     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14737    | 0.14737    | 0.14737    |   0.0 |  0.07
Output  | 0.00017509 | 0.00017509 | 0.00017509 |   0.0 |  0.00
Modify  | 0.696      | 0.696      | 0.696      |   0.0 |  0.35
Other   |            | 0.09843    |            |       |  0.05

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:      314718.0 ave      314718 max      314718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314718
Ave neighs/atom = 78.679500
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.017779309485, Press = 7.24734496649583
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -17493.291   -17493.291   -17644.589   -17644.589    292.69671    292.69671    43974.224    43974.224   -165.29371   -165.29371 
   16000   -17493.519   -17493.519   -17642.314   -17642.314    287.85461    287.85461    43980.123    43980.123     -475.943     -475.943 
Loop time of 200.083 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.579 hours/ns, 4.998 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    | 199.14     | 199.14     | 199.14     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1483     | 0.1483     | 0.1483     |   0.0 |  0.07
Output  | 0.00017607 | 0.00017607 | 0.00017607 |   0.0 |  0.00
Modify  | 0.69471    | 0.69471    | 0.69471    |   0.0 |  0.35
Other   |            | 0.09902    |            |       |  0.05

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:      314714.0 ave      314714 max      314714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314714
Ave neighs/atom = 78.678500
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.913350998355, Press = 5.0911998891721
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17493.519   -17493.519   -17642.314   -17642.314    287.85461    287.85461    43980.123    43980.123     -475.943     -475.943 
   17000   -17490.231   -17490.231   -17642.022   -17642.022    293.64954    293.64954    43984.104    43984.104   -463.99417   -463.99417 
Loop time of 199.587 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.441 hours/ns, 5.010 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    | 198.64     | 198.64     | 198.64     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14892    | 0.14892    | 0.14892    |   0.0 |  0.07
Output  | 0.00017723 | 0.00017723 | 0.00017723 |   0.0 |  0.00
Modify  | 0.69532    | 0.69532    | 0.69532    |   0.0 |  0.35
Other   |            | 0.09825    |            |       |  0.05

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:      314786.0 ave      314786 max      314786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314786
Ave neighs/atom = 78.696500
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.83135555712, Press = 2.50502752805556
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -17490.231   -17490.231   -17642.022   -17642.022    293.64954    293.64954    43984.104    43984.104   -463.99417   -463.99417 
   18000   -17496.457   -17496.457    -17644.62    -17644.62     286.6304     286.6304    43981.345    43981.345   -584.68226   -584.68226 
Loop time of 201.279 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.911 hours/ns, 4.968 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    | 200.32     | 200.32     | 200.32     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14987    | 0.14987    | 0.14987    |   0.0 |  0.07
Output  | 0.00023007 | 0.00023007 | 0.00023007 |   0.0 |  0.00
Modify  | 0.7086     | 0.7086     | 0.7086     |   0.0 |  0.35
Other   |            | 0.09949    |            |       |  0.05

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:      314712.0 ave      314712 max      314712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314712
Ave neighs/atom = 78.678000
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.739982805885, Press = 1.3043101938311
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17496.457   -17496.457    -17644.62    -17644.62     286.6304     286.6304    43981.345    43981.345   -584.68226   -584.68226 
   19000   -17492.493   -17492.493   -17645.827   -17645.827    296.63403    296.63403    43979.426    43979.426   -543.75974   -543.75974 
Loop time of 200.291 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.636 hours/ns, 4.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    | 199.34     | 199.34     | 199.34     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14899    | 0.14899    | 0.14899    |   0.0 |  0.07
Output  | 0.00017384 | 0.00017384 | 0.00017384 |   0.0 |  0.00
Modify  | 0.70309    | 0.70309    | 0.70309    |   0.0 |  0.35
Other   |            | 0.09815    |            |       |  0.05

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:      314720.0 ave      314720 max      314720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314720
Ave neighs/atom = 78.680000
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.718143798331, Press = 0.0118251638936145
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17492.493   -17492.493   -17645.827   -17645.827    296.63403    296.63403    43979.426    43979.426   -543.75974   -543.75974 
   20000   -17491.249   -17491.249   -17644.534   -17644.534    296.54132    296.54132    43995.669    43995.669   -1030.5089   -1030.5089 
Loop time of 198.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.069 hours/ns, 5.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    | 197.3      | 197.3      | 197.3      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.148      | 0.148      | 0.148      |   0.0 |  0.07
Output  | 0.00017627 | 0.00017627 | 0.00017627 |   0.0 |  0.00
Modify  | 0.69889    | 0.69889    | 0.69889    |   0.0 |  0.35
Other   |            | 0.09808    |            |       |  0.05

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:      314754.0 ave      314754 max      314754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314754
Ave neighs/atom = 78.688500
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.641374999611, Press = 0.12757909809705
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17491.249   -17491.249   -17644.534   -17644.534    296.54132    296.54132    43995.669    43995.669   -1030.5089   -1030.5089 
   21000   -17493.513   -17493.513     -17644.2     -17644.2    291.51434    291.51434    44015.562    44015.562   -1918.3408   -1918.3408 
Loop time of 198.09 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.025 hours/ns, 5.048 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    | 197.15     | 197.15     | 197.15     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14812    | 0.14812    | 0.14812    |   0.0 |  0.07
Output  | 0.00017744 | 0.00017744 | 0.00017744 |   0.0 |  0.00
Modify  | 0.69376    | 0.69376    | 0.69376    |   0.0 |  0.35
Other   |            | 0.09811    |            |       |  0.05

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:      314684.0 ave      314684 max      314684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314684
Ave neighs/atom = 78.671000
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.657324631999, Press = 0.263684870260845
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -17493.513   -17493.513     -17644.2     -17644.2    291.51434    291.51434    44015.562    44015.562   -1918.3408   -1918.3408 
   22000   -17493.849   -17493.849   -17644.285   -17644.285    291.02851    291.02851    44019.342    44019.342   -1976.6726   -1976.6726 
Loop time of 199.42 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.394 hours/ns, 5.015 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    | 198.48     | 198.48     | 198.48     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14977    | 0.14977    | 0.14977    |   0.0 |  0.08
Output  | 0.00017461 | 0.00017461 | 0.00017461 |   0.0 |  0.00
Modify  | 0.69613    | 0.69613    | 0.69613    |   0.0 |  0.35
Other   |            | 0.09802    |            |       |  0.05

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:      314708.0 ave      314708 max      314708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314708
Ave neighs/atom = 78.677000
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.674231302892, Press = 0.343592221892669
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17493.849   -17493.849   -17644.285   -17644.285    291.02851    291.02851    44019.342    44019.342   -1976.6726   -1976.6726 
   23000   -17492.524   -17492.524   -17642.338   -17642.338    289.82601    289.82601     44014.85     44014.85   -1712.0649   -1712.0649 
Loop time of 200.032 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.565 hours/ns, 4.999 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    | 199.08     | 199.08     | 199.08     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14932    | 0.14932    | 0.14932    |   0.0 |  0.07
Output  | 0.00022544 | 0.00022544 | 0.00022544 |   0.0 |  0.00
Modify  | 0.70294    | 0.70294    | 0.70294    |   0.0 |  0.35
Other   |            | 0.09906    |            |       |  0.05

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:      314536.0 ave      314536 max      314536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314536
Ave neighs/atom = 78.634000
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.557877075939, Press = 0.571690541836444
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -17492.524   -17492.524   -17642.338   -17642.338    289.82601    289.82601     44014.85     44014.85   -1712.0649   -1712.0649 
   24000   -17496.216   -17496.216   -17643.422   -17643.422    284.77966    284.77966    44009.904    44009.904   -1756.8085   -1756.8085 
Loop time of 198.425 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.118 hours/ns, 5.040 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    | 197.48     | 197.48     | 197.48     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14814    | 0.14814    | 0.14814    |   0.0 |  0.07
Output  | 0.00022625 | 0.00022625 | 0.00022625 |   0.0 |  0.00
Modify  | 0.6945     | 0.6945     | 0.6945     |   0.0 |  0.35
Other   |            | 0.09729    |            |       |  0.05

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:      314630.0 ave      314630 max      314630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314630
Ave neighs/atom = 78.657500
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.533624967565, Press = 0.797698898316816
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -17496.216   -17496.216   -17643.422   -17643.422    284.77966    284.77966    44009.904    44009.904   -1756.8085   -1756.8085 
   25000   -17490.999   -17490.999    -17646.36    -17646.36    300.55583    300.55583    44019.213    44019.213    -2048.459    -2048.459 
Loop time of 199.013 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.281 hours/ns, 5.025 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.07     | 198.07     | 198.07     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14892    | 0.14892    | 0.14892    |   0.0 |  0.07
Output  | 0.0001778  | 0.0001778  | 0.0001778  |   0.0 |  0.00
Modify  | 0.69754    | 0.69754    | 0.69754    |   0.0 |  0.35
Other   |            | 0.09868    |            |       |  0.05

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:      314604.0 ave      314604 max      314604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314604
Ave neighs/atom = 78.651000
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.60227488554, Press = 0.355627003547593
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -17490.999   -17490.999    -17646.36    -17646.36    300.55583    300.55583    44019.213    44019.213    -2048.459    -2048.459 
   26000   -17494.018   -17494.018   -17645.227   -17645.227    292.52369    292.52369    44001.482    44001.482   -1428.4025   -1428.4025 
Loop time of 200.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.730 hours/ns, 4.984 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    | 199.68     | 199.68     | 199.68     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14931    | 0.14931    | 0.14931    |   0.0 |  0.07
Output  | 0.00017762 | 0.00017762 | 0.00017762 |   0.0 |  0.00
Modify  | 0.69875    | 0.69875    | 0.69875    |   0.0 |  0.35
Other   |            | 0.09839    |            |       |  0.05

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:      314502.0 ave      314502 max      314502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314502
Ave neighs/atom = 78.625500
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.609153619162, Press = 0.13683855573181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17494.018   -17494.018   -17645.227   -17645.227    292.52369    292.52369    44001.482    44001.482   -1428.4025   -1428.4025 
   27000   -17488.828   -17488.828   -17641.024   -17641.024    294.43233    294.43233    43991.953    43991.953   -782.89126   -782.89126 
Loop time of 197.047 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.735 hours/ns, 5.075 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    | 196.12     | 196.12     | 196.12     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14645    | 0.14645    | 0.14645    |   0.0 |  0.07
Output  | 0.00017729 | 0.00017729 | 0.00017729 |   0.0 |  0.00
Modify  | 0.68383    | 0.68383    | 0.68383    |   0.0 |  0.35
Other   |            | 0.09758    |            |       |  0.05

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:      314596.0 ave      314596 max      314596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314596
Ave neighs/atom = 78.649000
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.664332933582, Press = -0.14970504004577
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17488.828   -17488.828   -17641.024   -17641.024    294.43233    294.43233    43991.953    43991.953   -782.89126   -782.89126 
   28000    -17489.47    -17489.47   -17643.266   -17643.266    297.52938    297.52938    43981.352    43981.352   -484.26944   -484.26944 
Loop time of 197.726 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.924 hours/ns, 5.057 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    | 196.79     | 196.79     | 196.79     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14658    | 0.14658    | 0.14658    |   0.0 |  0.07
Output  | 0.00017404 | 0.00017404 | 0.00017404 |   0.0 |  0.00
Modify  | 0.6889     | 0.6889     | 0.6889     |   0.0 |  0.35
Other   |            | 0.09761    |            |       |  0.05

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:      314782.0 ave      314782 max      314782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314782
Ave neighs/atom = 78.695500
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.663213884468, Press = -0.298860596842766
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000    -17489.47    -17489.47   -17643.266   -17643.266    297.52938    297.52938    43981.352    43981.352   -484.26944   -484.26944 
   29000   -17494.049   -17494.049   -17645.189   -17645.189    292.39081    292.39081    43980.146    43980.146   -473.63264   -473.63264 
Loop time of 197.157 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.766 hours/ns, 5.072 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    | 196.22     | 196.22     | 196.22     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14733    | 0.14733    | 0.14733    |   0.0 |  0.07
Output  | 0.00017602 | 0.00017602 | 0.00017602 |   0.0 |  0.00
Modify  | 0.68951    | 0.68951    | 0.68951    |   0.0 |  0.35
Other   |            | 0.09811    |            |       |  0.05

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:      314698.0 ave      314698 max      314698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314698
Ave neighs/atom = 78.674500
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.637573255268, Press = -0.720692033734591
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -17494.049   -17494.049   -17645.189   -17645.189    292.39081    292.39081    43980.146    43980.146   -473.63264   -473.63264 
   30000   -17494.539   -17494.539   -17644.976   -17644.976    291.03179    291.03179    43997.271    43997.271   -1044.0181   -1044.0181 
Loop time of 198.935 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.260 hours/ns, 5.027 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    | 197.99     | 197.99     | 197.99     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14919    | 0.14919    | 0.14919    |   0.0 |  0.07
Output  | 0.00040573 | 0.00040573 | 0.00040573 |   0.0 |  0.00
Modify  | 0.6946     | 0.6946     | 0.6946     |   0.0 |  0.35
Other   |            | 0.09871    |            |       |  0.05

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:      314592.0 ave      314592 max      314592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314592
Ave neighs/atom = 78.648000
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.683291323569, Press = -0.400304720519078
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17494.539   -17494.539   -17644.976   -17644.976    291.03179    291.03179    43997.271    43997.271   -1044.0181   -1044.0181 
   31000   -17488.549   -17488.549   -17641.134   -17641.134    295.18437    295.18437    44025.493    44025.493   -2009.5067   -2009.5067 
Loop time of 199.924 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.534 hours/ns, 5.002 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    | 198.97     | 198.97     | 198.97     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1494     | 0.1494     | 0.1494     |   0.0 |  0.07
Output  | 0.00016904 | 0.00016904 | 0.00016904 |   0.0 |  0.00
Modify  | 0.70076    | 0.70076    | 0.70076    |   0.0 |  0.35
Other   |            | 0.09861    |            |       |  0.05

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:      314648.0 ave      314648 max      314648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314648
Ave neighs/atom = 78.662000
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.748089288955, Press = -0.820604282884744
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17488.549   -17488.549   -17641.134   -17641.134    295.18437    295.18437    44025.493    44025.493   -2009.5067   -2009.5067 
   32000   -17495.591   -17495.591   -17644.328   -17644.328    287.74132    287.74132    44022.961    44022.961   -2160.6789   -2160.6789 
Loop time of 201.878 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.077 hours/ns, 4.953 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    | 200.91     | 200.91     | 200.91     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15122    | 0.15122    | 0.15122    |   0.0 |  0.07
Output  | 0.00025662 | 0.00025662 | 0.00025662 |   0.0 |  0.00
Modify  | 0.71279    | 0.71279    | 0.71279    |   0.0 |  0.35
Other   |            | 0.0998     |            |       |  0.05

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:      314660.0 ave      314660 max      314660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314660
Ave neighs/atom = 78.665000
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.749287688107, Press = -1.17597993834494
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -17495.591   -17495.591   -17644.328   -17644.328    287.74132    287.74132    44022.961    44022.961   -2160.6789   -2160.6789 
   33000    -17492.33    -17492.33   -17642.614   -17642.614    290.73391    290.73391    44006.193    44006.193   -1311.5329   -1311.5329 
Loop time of 199.208 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.336 hours/ns, 5.020 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    | 198.26     | 198.26     | 198.26     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1482     | 0.1482     | 0.1482     |   0.0 |  0.07
Output  | 0.00017497 | 0.00017497 | 0.00017497 |   0.0 |  0.00
Modify  | 0.69992    | 0.69992    | 0.69992    |   0.0 |  0.35
Other   |            | 0.09875    |            |       |  0.05

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:      314502.0 ave      314502 max      314502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314502
Ave neighs/atom = 78.625500
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.781552721297, Press = -1.05599453574232
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    -17492.33    -17492.33   -17642.614   -17642.614    290.73391    290.73391    44006.193    44006.193   -1311.5329   -1311.5329 
   34000    -17486.43    -17486.43   -17639.842   -17639.842     296.7861     296.7861    43987.112    43987.112   -507.85508   -507.85508 
Loop time of 200.326 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.646 hours/ns, 4.992 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    | 199.37     | 199.37     | 199.37     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14893    | 0.14893    | 0.14893    |   0.0 |  0.07
Output  | 0.00017699 | 0.00017699 | 0.00017699 |   0.0 |  0.00
Modify  | 0.70659    | 0.70659    | 0.70659    |   0.0 |  0.35
Other   |            | 0.09913    |            |       |  0.05

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:      314646.0 ave      314646 max      314646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314646
Ave neighs/atom = 78.661500
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.81010562952, Press = -0.617971952299286
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000    -17486.43    -17486.43   -17639.842   -17639.842     296.7861     296.7861    43987.112    43987.112   -507.85508   -507.85508 
   35000   -17492.269   -17492.269   -17643.504   -17643.504    292.57396    292.57396    43973.277    43973.277    -92.00985    -92.00985 
Loop time of 199.928 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.535 hours/ns, 5.002 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    | 198.98     | 198.98     | 198.98     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14898    | 0.14898    | 0.14898    |   0.0 |  0.07
Output  | 0.00018054 | 0.00018054 | 0.00018054 |   0.0 |  0.00
Modify  | 0.70202    | 0.70202    | 0.70202    |   0.0 |  0.35
Other   |            | 0.09927    |            |       |  0.05

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:      314780.0 ave      314780 max      314780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314780
Ave neighs/atom = 78.695000
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.86019865642, Press = -0.752717389969315
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -17492.269   -17492.269   -17643.504   -17643.504    292.57396    292.57396    43973.277    43973.277    -92.00985    -92.00985 
   36000    -17495.11    -17495.11   -17643.039   -17643.039     286.1801     286.1801    43968.306    43968.306   -91.362782   -91.362782 
Loop time of 202.522 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.256 hours/ns, 4.938 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    | 201.56     | 201.56     | 201.56     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15017    | 0.15017    | 0.15017    |   0.0 |  0.07
Output  | 0.00017605 | 0.00017605 | 0.00017605 |   0.0 |  0.00
Modify  | 0.70844    | 0.70844    | 0.70844    |   0.0 |  0.35
Other   |            | 0.09974    |            |       |  0.05

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:      314760.0 ave      314760 max      314760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314760
Ave neighs/atom = 78.690000
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.913465985938, Press = -0.864959342541998
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000    -17495.11    -17495.11   -17643.039   -17643.039     286.1801     286.1801    43968.306    43968.306   -91.362782   -91.362782 
   37000   -17493.593   -17493.593   -17644.716   -17644.716    292.35842    292.35842    43967.295    43967.295    131.86956    131.86956 
Loop time of 200.573 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.715 hours/ns, 4.986 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    | 199.62     | 199.62     | 199.62     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14996    | 0.14996    | 0.14996    |   0.0 |  0.07
Output  | 0.00028651 | 0.00028651 | 0.00028651 |   0.0 |  0.00
Modify  | 0.70404    | 0.70404    | 0.70404    |   0.0 |  0.35
Other   |            | 0.0997     |            |       |  0.05

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:      314818.0 ave      314818 max      314818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314818
Ave neighs/atom = 78.704500
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.910879493086, Press = -1.18376226286109
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -17493.593   -17493.593   -17644.716   -17644.716    292.35842    292.35842    43967.295    43967.295    131.86956    131.86956 
   38000    -17490.54    -17490.54   -17642.986   -17642.986    294.91607    294.91607     43963.08     43963.08    402.31561    402.31561 
Loop time of 200.483 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.690 hours/ns, 4.988 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    | 199.53     | 199.53     | 199.53     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14944    | 0.14944    | 0.14944    |   0.0 |  0.07
Output  | 0.00017756 | 0.00017756 | 0.00017756 |   0.0 |  0.00
Modify  | 0.70788    | 0.70788    | 0.70788    |   0.0 |  0.35
Other   |            | 0.09886    |            |       |  0.05

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:      314656.0 ave      314656 max      314656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314656
Ave neighs/atom = 78.664000
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.858729076975, Press = -1.35477865651681
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000    -17490.54    -17490.54   -17642.986   -17642.986    294.91607    294.91607     43963.08     43963.08    402.31561    402.31561 
   39000   -17499.465   -17499.465    -17646.77    -17646.77    284.97138    284.97138    43940.515    43940.515    932.46016    932.46016 
Loop time of 202.074 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.132 hours/ns, 4.949 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    | 201.11     | 201.11     | 201.11     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15079    | 0.15079    | 0.15079    |   0.0 |  0.07
Output  | 0.00017576 | 0.00017576 | 0.00017576 |   0.0 |  0.00
Modify  | 0.71388    | 0.71388    | 0.71388    |   0.0 |  0.35
Other   |            | 0.09858    |            |       |  0.05

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:      314932.0 ave      314932 max      314932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314932
Ave neighs/atom = 78.733000
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.831686076246, Press = -1.47237414344079
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -17499.465   -17499.465    -17646.77    -17646.77    284.97138    284.97138    43940.515    43940.515    932.46016    932.46016 
   40000    -17489.45    -17489.45   -17642.014   -17642.014    295.14543    295.14543    43925.111    43925.111    2046.6135    2046.6135 
Loop time of 203.5 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.528 hours/ns, 4.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    | 202.53     | 202.53     | 202.53     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15092    | 0.15092    | 0.15092    |   0.0 |  0.07
Output  | 0.00017779 | 0.00017779 | 0.00017779 |   0.0 |  0.00
Modify  | 0.71728    | 0.71728    | 0.71728    |   0.0 |  0.35
Other   |            | 0.09993    |            |       |  0.05

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:      314722.0 ave      314722 max      314722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314722
Ave neighs/atom = 78.680500
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.794669853339, Press = -1.61970210261925
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000    -17489.45    -17489.45   -17642.014   -17642.014    295.14543    295.14543    43925.111    43925.111    2046.6135    2046.6135 
   41000   -17491.942   -17491.942   -17642.941   -17642.941    292.11856    292.11856    43955.429    43955.429    670.92597    670.92597 
Loop time of 199.066 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.296 hours/ns, 5.023 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    | 198.12     | 198.12     | 198.12     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14778    | 0.14778    | 0.14778    |   0.0 |  0.07
Output  | 0.00017439 | 0.00017439 | 0.00017439 |   0.0 |  0.00
Modify  | 0.69656    | 0.69656    | 0.69656    |   0.0 |  0.35
Other   |            | 0.0988     |            |       |  0.05

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:      314854.0 ave      314854 max      314854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314854
Ave neighs/atom = 78.713500
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.802248195084, Press = -1.08659329196803
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -17491.942   -17491.942   -17642.941   -17642.941    292.11856    292.11856    43955.429    43955.429    670.92597    670.92597 
   42000   -17492.812   -17492.812   -17641.912   -17641.912    288.44279    288.44279    43957.811    43957.811    545.17686    545.17686 
Loop time of 197.595 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.888 hours/ns, 5.061 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    | 196.67     | 196.67     | 196.67     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14638    | 0.14638    | 0.14638    |   0.0 |  0.07
Output  | 0.00017479 | 0.00017479 | 0.00017479 |   0.0 |  0.00
Modify  | 0.68561    | 0.68561    | 0.68561    |   0.0 |  0.35
Other   |            | 0.0976     |            |       |  0.05

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:      314794.0 ave      314794 max      314794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314794
Ave neighs/atom = 78.698500
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.863166984877, Press = -0.554576671057075
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -17492.812   -17492.812   -17641.912   -17641.912    288.44279    288.44279    43957.811    43957.811    545.17686    545.17686 
   43000   -17489.461   -17489.461    -17641.25    -17641.25    293.64604    293.64604    43965.272    43965.272    339.07104    339.07104 
Loop time of 206.25 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.292 hours/ns, 4.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    | 205.27     | 205.27     | 205.27     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15246    | 0.15246    | 0.15246    |   0.0 |  0.07
Output  | 0.00016975 | 0.00016975 | 0.00016975 |   0.0 |  0.00
Modify  | 0.7307     | 0.7307     | 0.7307     |   0.0 |  0.35
Other   |            | 0.1006     |            |       |  0.05

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:      314804.0 ave      314804 max      314804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314804
Ave neighs/atom = 78.701000
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.871864541644, Press = -0.550277668219026
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -17489.461   -17489.461    -17641.25    -17641.25    293.64604    293.64604    43965.272    43965.272    339.07104    339.07104 
   44000   -17491.959   -17491.959   -17643.677   -17643.677    293.50779    293.50779    43963.511    43963.511    248.26571    248.26571 
Loop time of 204.899 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.916 hours/ns, 4.880 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    | 203.92     | 203.92     | 203.92     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15003    | 0.15003    | 0.15003    |   0.0 |  0.07
Output  | 0.00017495 | 0.00017495 | 0.00017495 |   0.0 |  0.00
Modify  | 0.72328    | 0.72328    | 0.72328    |   0.0 |  0.35
Other   |            | 0.1007     |            |       |  0.05

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:      314784.0 ave      314784 max      314784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314784
Ave neighs/atom = 78.696000
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.877995490059, Press = -0.788138377405827
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -17491.959   -17491.959   -17643.677   -17643.677    293.50779    293.50779    43963.511    43963.511    248.26571    248.26571 
   45000   -17490.093   -17490.093   -17642.649   -17642.649    295.13103    295.13103    43949.294    43949.294    1018.2825    1018.2825 
Loop time of 201.922 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.089 hours/ns, 4.952 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    | 200.96     | 200.96     | 200.96     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14922    | 0.14922    | 0.14922    |   0.0 |  0.07
Output  | 0.00023032 | 0.00023032 | 0.00023032 |   0.0 |  0.00
Modify  | 0.71227    | 0.71227    | 0.71227    |   0.0 |  0.35
Other   |            | 0.09997    |            |       |  0.05

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:      314756.0 ave      314756 max      314756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314756
Ave neighs/atom = 78.689000
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.896907492487, Press = -1.22517262016509
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -17490.093   -17490.093   -17642.649   -17642.649    295.13103    295.13103    43949.294    43949.294    1018.2825    1018.2825 
   46000   -17492.302   -17492.302   -17644.042   -17644.042    293.55216    293.55216    43950.043    43950.043    925.48604    925.48604 
Loop time of 202.35 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.208 hours/ns, 4.942 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    | 201.39     | 201.39     | 201.39     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14906    | 0.14906    | 0.14906    |   0.0 |  0.07
Output  | 0.00017524 | 0.00017524 | 0.00017524 |   0.0 |  0.00
Modify  | 0.7109     | 0.7109     | 0.7109     |   0.0 |  0.35
Other   |            | 0.09978    |            |       |  0.05

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:      314814.0 ave      314814 max      314814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314814
Ave neighs/atom = 78.703500
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.918279694291, Press = -1.21934610032829
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -17492.302   -17492.302   -17644.042   -17644.042    293.55216    293.55216    43950.043    43950.043    925.48604    925.48604 
   47000     -17491.9     -17491.9   -17643.013   -17643.013    292.33789    292.33789    43945.214    43945.214    1024.0544    1024.0544 
Loop time of 201.962 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.101 hours/ns, 4.951 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201        | 201        | 201        |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15082    | 0.15082    | 0.15082    |   0.0 |  0.07
Output  | 0.00017323 | 0.00017323 | 0.00017323 |   0.0 |  0.00
Modify  | 0.71328    | 0.71328    | 0.71328    |   0.0 |  0.35
Other   |            | 0.1004     |            |       |  0.05

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:      314684.0 ave      314684 max      314684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314684
Ave neighs/atom = 78.671000
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.959350922786, Press = -1.36683606495523
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000     -17491.9     -17491.9   -17643.013   -17643.013    292.33789    292.33789    43945.214    43945.214    1024.0544    1024.0544 
   48000   -17490.117   -17490.117   -17641.991   -17641.991    293.80978    293.80978    43945.757    43945.757    1199.6836    1199.6836 
Loop time of 203.894 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.637 hours/ns, 4.904 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    | 202.92     | 202.92     | 202.92     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15068    | 0.15068    | 0.15068    |   0.0 |  0.07
Output  | 0.00017674 | 0.00017674 | 0.00017674 |   0.0 |  0.00
Modify  | 0.72617    | 0.72617    | 0.72617    |   0.0 |  0.36
Other   |            | 0.1007     |            |       |  0.05

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:      314878.0 ave      314878 max      314878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314878
Ave neighs/atom = 78.719500
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.9655937038, Press = -0.89382116519216
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -17490.117   -17490.117   -17641.991   -17641.991    293.80978    293.80978    43945.757    43945.757    1199.6836    1199.6836 
   49000   -17494.219   -17494.219    -17643.79    -17643.79      289.354      289.354     43948.74     43948.74    848.31678    848.31678 
Loop time of 203.996 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.666 hours/ns, 4.902 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    | 203.02     | 203.02     | 203.02     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15149    | 0.15149    | 0.15149    |   0.0 |  0.07
Output  | 0.00017751 | 0.00017751 | 0.00017751 |   0.0 |  0.00
Modify  | 0.72303    | 0.72303    | 0.72303    |   0.0 |  0.35
Other   |            | 0.1005     |            |       |  0.05

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:      314906.0 ave      314906 max      314906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314906
Ave neighs/atom = 78.726500
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.945808502736, Press = -0.699466048384111
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -17494.219   -17494.219    -17643.79    -17643.79      289.354      289.354     43948.74     43948.74    848.31678    848.31678 
   50000    -17495.31    -17495.31   -17646.402   -17646.402    292.29834    292.29834    43942.646    43942.646    988.63927    988.63927 
Loop time of 203.898 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.638 hours/ns, 4.904 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    | 202.93     | 202.93     | 202.93     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15044    | 0.15044    | 0.15044    |   0.0 |  0.07
Output  | 0.00017539 | 0.00017539 | 0.00017539 |   0.0 |  0.00
Modify  | 0.71696    | 0.71696    | 0.71696    |   0.0 |  0.35
Other   |            | 0.1005     |            |       |  0.05

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:      314828.0 ave      314828 max      314828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314828
Ave neighs/atom = 78.707000
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.926469146083, Press = -0.306489648218628
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000    -17495.31    -17495.31   -17646.402   -17646.402    292.29834    292.29834    43942.646    43942.646    988.63927    988.63927 
   51000   -17490.132   -17490.132   -17643.229   -17643.229     296.1774     296.1774    43949.025    43949.025    954.71694    954.71694 
Loop time of 204.581 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.828 hours/ns, 4.888 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    | 203.6      | 203.6      | 203.6      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15157    | 0.15157    | 0.15157    |   0.0 |  0.07
Output  | 0.00017665 | 0.00017665 | 0.00017665 |   0.0 |  0.00
Modify  | 0.72592    | 0.72592    | 0.72592    |   0.0 |  0.35
Other   |            | 0.101      |            |       |  0.05

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:      314730.0 ave      314730 max      314730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314730
Ave neighs/atom = 78.682500
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.911589045754, Press = -0.0155622898345999
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -17490.132   -17490.132   -17643.229   -17643.229     296.1774     296.1774    43949.025    43949.025    954.71694    954.71694 
   52000    -17493.23    -17493.23   -17646.012   -17646.012    295.56611    295.56611    43918.333    43918.333    1973.1927    1973.1927 
Loop time of 201.601 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 56.000 hours/ns, 4.960 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    | 200.64     | 200.64     | 200.64     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14781    | 0.14781    | 0.14781    |   0.0 |  0.07
Output  | 0.00017584 | 0.00017584 | 0.00017584 |   0.0 |  0.00
Modify  | 0.71048    | 0.71048    | 0.71048    |   0.0 |  0.35
Other   |            | 0.09971    |            |       |  0.05

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:      314682.0 ave      314682 max      314682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314682
Ave neighs/atom = 78.670500
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.922192608178, Press = 0.0515420960319892
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000    -17493.23    -17493.23   -17646.012   -17646.012    295.56611    295.56611    43918.333    43918.333    1973.1927    1973.1927 
   53000   -17494.576   -17494.576   -17645.319   -17645.319    291.62213    291.62213     43869.52     43869.52    4032.0573    4032.0573 
Loop time of 200.683 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.745 hours/ns, 4.983 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    | 199.73     | 199.73     | 199.73     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14762    | 0.14762    | 0.14762    |   0.0 |  0.07
Output  | 0.0002151  | 0.0002151  | 0.0002151  |   0.0 |  0.00
Modify  | 0.70507    | 0.70507    | 0.70507    |   0.0 |  0.35
Other   |            | 0.09904    |            |       |  0.05

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:      314850.0 ave      314850 max      314850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314850
Ave neighs/atom = 78.712500
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.95504845923, Press = 0.718965546093762
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -17494.576   -17494.576   -17645.319   -17645.319    291.62213    291.62213     43869.52     43869.52    4032.0573    4032.0573 
   54000   -17490.102   -17490.102   -17645.096   -17645.096    299.84692    299.84692    43923.905    43923.905    1771.9604    1771.9604 
Loop time of 205.255 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 57.015 hours/ns, 4.872 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    | 204.28     | 204.28     | 204.28     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14901    | 0.14901    | 0.14901    |   0.0 |  0.07
Output  | 0.00017773 | 0.00017773 | 0.00017773 |   0.0 |  0.00
Modify  | 0.7209     | 0.7209     | 0.7209     |   0.0 |  0.35
Other   |            | 0.1017     |            |       |  0.05

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:      314962.0 ave      314962 max      314962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314962
Ave neighs/atom = 78.740500
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.951445420274, Press = 0.58754359944675
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -17490.102   -17490.102   -17645.096   -17645.096    299.84692    299.84692    43923.905    43923.905    1771.9604    1771.9604 
   55000   -17492.229   -17492.229   -17645.017   -17645.017    295.57707    295.57707    43946.085    43946.085    864.54579    864.54579 
Loop time of 208.767 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.414 ns/day, 57.991 hours/ns, 4.790 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 207.77     | 207.77     | 207.77     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.151      | 0.151      | 0.151      |   0.0 |  0.07
Output  | 0.00017497 | 0.00017497 | 0.00017497 |   0.0 |  0.00
Modify  | 0.74283    | 0.74283    | 0.74283    |   0.0 |  0.36
Other   |            | 0.1024     |            |       |  0.05

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:      314848.0 ave      314848 max      314848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314848
Ave neighs/atom = 78.712000
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.955729242477, Press = 0.591577366795139
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -17492.229   -17492.229   -17645.017   -17645.017    295.57707    295.57707    43946.085    43946.085    864.54579    864.54579 
   56000   -17492.835   -17492.835   -17646.055   -17646.055    296.41464    296.41464    43954.332    43954.332    495.23207    495.23207 
Loop time of 204.091 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.692 hours/ns, 4.900 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    | 203.12     | 203.12     | 203.12     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14799    | 0.14799    | 0.14799    |   0.0 |  0.07
Output  | 0.00017542 | 0.00017542 | 0.00017542 |   0.0 |  0.00
Modify  | 0.72464    | 0.72464    | 0.72464    |   0.0 |  0.36
Other   |            | 0.1018     |            |       |  0.05

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:      314782.0 ave      314782 max      314782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314782
Ave neighs/atom = 78.695500
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.962999205053, Press = 0.579609468446568
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -17492.835   -17492.835   -17646.055   -17646.055    296.41464    296.41464    43954.332    43954.332    495.23207    495.23207 
   57000   -17490.291   -17490.291   -17641.909   -17641.909    293.31417    293.31417     43960.67     43960.67    466.81827    466.81827 
Loop time of 202.994 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.387 hours/ns, 4.926 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    | 202.03     | 202.03     | 202.03     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14861    | 0.14861    | 0.14861    |   0.0 |  0.07
Output  | 0.00017897 | 0.00017897 | 0.00017897 |   0.0 |  0.00
Modify  | 0.71631    | 0.71631    | 0.71631    |   0.0 |  0.35
Other   |            | 0.1002     |            |       |  0.05

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:      314876.0 ave      314876 max      314876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314876
Ave neighs/atom = 78.719000
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.984121635271, Press = 0.508791625970712
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -17490.291   -17490.291   -17641.909   -17641.909    293.31417    293.31417     43960.67     43960.67    466.81827    466.81827 
   58000   -17491.784   -17491.784   -17646.074   -17646.074    298.48338    298.48338    43961.553    43961.553    337.87275    337.87275 
Loop time of 207.405 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.613 hours/ns, 4.821 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    | 206.41     | 206.41     | 206.41     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15315    | 0.15315    | 0.15315    |   0.0 |  0.07
Output  | 0.00022798 | 0.00022798 | 0.00022798 |   0.0 |  0.00
Modify  | 0.74073    | 0.74073    | 0.74073    |   0.0 |  0.36
Other   |            | 0.1013     |            |       |  0.05

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:      314874.0 ave      314874 max      314874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314874
Ave neighs/atom = 78.718500
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.991770036251, Press = 0.747085040394676
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -17491.784   -17491.784   -17646.074   -17646.074    298.48338    298.48338    43961.553    43961.553    337.87275    337.87275 
   59000    -17494.32    -17494.32   -17643.994   -17643.994     289.5546     289.5546    43942.108    43942.108    1093.5406    1093.5406 
Loop time of 207.368 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.602 hours/ns, 4.822 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    | 206.38     | 206.38     | 206.38     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15172    | 0.15172    | 0.15172    |   0.0 |  0.07
Output  | 0.00017925 | 0.00017925 | 0.00017925 |   0.0 |  0.00
Modify  | 0.73574    | 0.73574    | 0.73574    |   0.0 |  0.35
Other   |            | 0.1014     |            |       |  0.05

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:      314732.0 ave      314732 max      314732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314732
Ave neighs/atom = 78.683000
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.988295928248, Press = 1.39136658308837
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000    -17494.32    -17494.32   -17643.994   -17643.994     289.5546     289.5546    43942.108    43942.108    1093.5406    1093.5406 
   60000   -17490.527   -17490.527   -17641.844   -17641.844    292.73222    292.73222    43965.023    43965.023    344.89828    344.89828 
Loop time of 204.021 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.673 hours/ns, 4.901 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    | 203.05     | 203.05     | 203.05     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1489     | 0.1489     | 0.1489     |   0.0 |  0.07
Output  | 0.00017681 | 0.00017681 | 0.00017681 |   0.0 |  0.00
Modify  | 0.72287    | 0.72287    | 0.72287    |   0.0 |  0.35
Other   |            | 0.1012     |            |       |  0.05

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:      314802.0 ave      314802 max      314802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314802
Ave neighs/atom = 78.700500
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.999583150608, Press = 1.10282134998224
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -17490.527   -17490.527   -17641.844   -17641.844    292.73222    292.73222    43965.023    43965.023    344.89828    344.89828 
   61000   -17492.848   -17492.848    -17641.39    -17641.39    287.36575    287.36575    43961.616    43961.616    246.79021    246.79021 
Loop time of 205.577 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.105 hours/ns, 4.864 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    | 204.59     | 204.59     | 204.59     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15105    | 0.15105    | 0.15105    |   0.0 |  0.07
Output  | 0.00017731 | 0.00017731 | 0.00017731 |   0.0 |  0.00
Modify  | 0.7303     | 0.7303     | 0.7303     |   0.0 |  0.36
Other   |            | 0.1018     |            |       |  0.05

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:      314778.0 ave      314778 max      314778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314778
Ave neighs/atom = 78.694500
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.018677368382, Press = 0.447174892487922
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -17492.848   -17492.848    -17641.39    -17641.39    287.36575    287.36575    43961.616    43961.616    246.79021    246.79021 
   62000   -17494.832   -17494.832   -17644.227   -17644.227     289.0152     289.0152    43967.358    43967.358    42.062333    42.062333 
Loop time of 204.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.713 hours/ns, 4.898 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    | 203.2      | 203.2      | 203.2      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14875    | 0.14875    | 0.14875    |   0.0 |  0.07
Output  | 0.00017858 | 0.00017858 | 0.00017858 |   0.0 |  0.00
Modify  | 0.71884    | 0.71884    | 0.71884    |   0.0 |  0.35
Other   |            | 0.1006     |            |       |  0.05

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:      314790.0 ave      314790 max      314790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314790
Ave neighs/atom = 78.697500
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.027275592892, Press = 0.325783629882652
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -17494.832   -17494.832   -17644.227   -17644.227     289.0152     289.0152    43967.358    43967.358    42.062333    42.062333 
   63000   -17495.193   -17495.193   -17644.026   -17644.026    287.92728    287.92728    43954.684    43954.684    476.02007    476.02007 
Loop time of 205.51 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.086 hours/ns, 4.866 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    | 204.53     | 204.53     | 204.53     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15027    | 0.15027    | 0.15027    |   0.0 |  0.07
Output  | 0.00029516 | 0.00029516 | 0.00029516 |   0.0 |  0.00
Modify  | 0.73169    | 0.73169    | 0.73169    |   0.0 |  0.36
Other   |            | 0.1014     |            |       |  0.05

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:      314788.0 ave      314788 max      314788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314788
Ave neighs/atom = 78.697000
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.01290478424, Press = 0.495322518007618
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -17495.193   -17495.193   -17644.026   -17644.026    287.92728    287.92728    43954.684    43954.684    476.02007    476.02007 
   64000   -17490.703   -17490.703   -17642.726   -17642.726    294.09916    294.09916    43980.738    43980.738   -380.06841   -380.06841 
Loop time of 206.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.291 hours/ns, 4.849 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    | 205.26     | 205.26     | 205.26     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15124    | 0.15124    | 0.15124    |   0.0 |  0.07
Output  | 0.00017723 | 0.00017723 | 0.00017723 |   0.0 |  0.00
Modify  | 0.73693    | 0.73693    | 0.73693    |   0.0 |  0.36
Other   |            | 0.1016     |            |       |  0.05

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:      314788.0 ave      314788 max      314788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314788
Ave neighs/atom = 78.697000
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.003032252204, Press = 1.07749636393267
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -17490.703   -17490.703   -17642.726   -17642.726    294.09916    294.09916    43980.738    43980.738   -380.06841   -380.06841 
   65000   -17493.595   -17493.595   -17641.491   -17641.491    286.11442    286.11442    43989.761    43989.761   -783.91392   -783.91392 
Loop time of 205.394 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 57.054 hours/ns, 4.869 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    | 204.41     | 204.41     | 204.41     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15016    | 0.15016    | 0.15016    |   0.0 |  0.07
Output  | 0.00017981 | 0.00017981 | 0.00017981 |   0.0 |  0.00
Modify  | 0.73272    | 0.73272    | 0.73272    |   0.0 |  0.36
Other   |            | 0.1005     |            |       |  0.05

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:      314798.0 ave      314798 max      314798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314798
Ave neighs/atom = 78.699500
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.984436588928, Press = 1.37249132081842
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -17493.595   -17493.595   -17641.491   -17641.491    286.11442    286.11442    43989.761    43989.761   -783.91392   -783.91392 
   66000   -17494.803   -17494.803   -17646.158   -17646.158     292.8068     292.8068    43975.787    43975.787   -249.33975   -249.33975 
Loop time of 202.391 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.220 hours/ns, 4.941 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    | 201.43     | 201.43     | 201.43     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14827    | 0.14827    | 0.14827    |   0.0 |  0.07
Output  | 0.00022054 | 0.00022054 | 0.00022054 |   0.0 |  0.00
Modify  | 0.71593    | 0.71593    | 0.71593    |   0.0 |  0.35
Other   |            | 0.1003     |            |       |  0.05

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:      314700.0 ave      314700 max      314700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314700
Ave neighs/atom = 78.675000
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.974444040307, Press = 0.323220480384463
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -17494.803   -17494.803   -17646.158   -17646.158     292.8068     292.8068    43975.787    43975.787   -249.33975   -249.33975 
   67000    -17491.34    -17491.34    -17640.81    -17640.81    289.15965    289.15965    43971.313    43971.313    147.87756    147.87756 
Loop time of 202.212 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.170 hours/ns, 4.945 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    | 201.24     | 201.24     | 201.24     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14829    | 0.14829    | 0.14829    |   0.0 |  0.07
Output  | 0.00022375 | 0.00022375 | 0.00022375 |   0.0 |  0.00
Modify  | 0.7181     | 0.7181     | 0.7181     |   0.0 |  0.36
Other   |            | 0.101      |            |       |  0.05

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:      314558.0 ave      314558 max      314558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314558
Ave neighs/atom = 78.639500
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.945563226843, Press = 0.103365032670404
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000    -17491.34    -17491.34    -17640.81    -17640.81    289.15965    289.15965    43971.313    43971.313    147.87756    147.87756 
   68000   -17495.707   -17495.707   -17645.827   -17645.827    290.41658    290.41658    43978.831    43978.831   -512.96806   -512.96806 
Loop time of 200.771 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.770 hours/ns, 4.981 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    | 199.81     | 199.81     | 199.81     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14826    | 0.14826    | 0.14826    |   0.0 |  0.07
Output  | 0.0002234  | 0.0002234  | 0.0002234  |   0.0 |  0.00
Modify  | 0.70872    | 0.70872    | 0.70872    |   0.0 |  0.35
Other   |            | 0.09981    |            |       |  0.05

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:      314758.0 ave      314758 max      314758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314758
Ave neighs/atom = 78.689500
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.932043535508, Press = 0.381637808409955
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -17495.707   -17495.707   -17645.827   -17645.827    290.41658    290.41658    43978.831    43978.831   -512.96806   -512.96806 
   69000   -17491.595   -17491.595   -17644.434   -17644.434     295.6777     295.6777     43980.62     43980.62   -295.73688   -295.73688 
Loop time of 205.312 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 57.031 hours/ns, 4.871 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    | 204.34     | 204.34     | 204.34     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15026    | 0.15026    | 0.15026    |   0.0 |  0.07
Output  | 0.00021392 | 0.00021392 | 0.00021392 |   0.0 |  0.00
Modify  | 0.72292    | 0.72292    | 0.72292    |   0.0 |  0.35
Other   |            | 0.1005     |            |       |  0.05

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:      314662.0 ave      314662 max      314662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314662
Ave neighs/atom = 78.665500
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.953728207894, Press = 0.58704212424088
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -17491.595   -17491.595   -17644.434   -17644.434     295.6777     295.6777     43980.62     43980.62   -295.73688   -295.73688 
   70000   -17496.656   -17496.656   -17647.303   -17647.303    291.43783    291.43783    43989.483    43989.483   -885.29747   -885.29747 
Loop time of 201.683 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.023 hours/ns, 4.958 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    | 200.73     | 200.73     | 200.73     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14724    | 0.14724    | 0.14724    |   0.0 |  0.07
Output  | 0.0001796  | 0.0001796  | 0.0001796  |   0.0 |  0.00
Modify  | 0.70752    | 0.70752    | 0.70752    |   0.0 |  0.35
Other   |            | 0.1        |            |       |  0.05

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:      314646.0 ave      314646 max      314646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314646
Ave neighs/atom = 78.661500
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.928845152363, Press = 0.877913409132377
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -17496.656   -17496.656   -17647.303   -17647.303    291.43783    291.43783    43989.483    43989.483   -885.29747   -885.29747 
   71000   -17493.933   -17493.933   -17641.977   -17641.977    286.40095    286.40095    43994.645    43994.645    -1038.566    -1038.566 
Loop time of 198.736 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.204 hours/ns, 5.032 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    | 197.79     | 197.79     | 197.79     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14635    | 0.14635    | 0.14635    |   0.0 |  0.07
Output  | 0.0012391  | 0.0012391  | 0.0012391  |   0.0 |  0.00
Modify  | 0.70114    | 0.70114    | 0.70114    |   0.0 |  0.35
Other   |            | 0.09977    |            |       |  0.05

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:      314594.0 ave      314594 max      314594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314594
Ave neighs/atom = 78.648500
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.934408257227, Press = 0.729633998080355
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -17493.933   -17493.933   -17641.977   -17641.977    286.40095    286.40095    43994.645    43994.645    -1038.566    -1038.566 
   72000   -17489.813   -17489.813   -17642.679   -17642.679    295.72911    295.72911    43992.931    43992.931   -906.15044   -906.15044 
Loop time of 205.14 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.983 hours/ns, 4.875 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    | 204.16     | 204.16     | 204.16     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15015    | 0.15015    | 0.15015    |   0.0 |  0.07
Output  | 0.00017641 | 0.00017641 | 0.00017641 |   0.0 |  0.00
Modify  | 0.72965    | 0.72965    | 0.72965    |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  0.05

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:      314752.0 ave      314752 max      314752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314752
Ave neighs/atom = 78.688000
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.955012073838, Press = 0.358152781877647
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -17489.813   -17489.813   -17642.679   -17642.679    295.72911    295.72911    43992.931    43992.931   -906.15044   -906.15044 
   73000   -17493.597   -17493.597   -17643.535   -17643.535    290.06559    290.06559     43984.07     43984.07    -728.3735    -728.3735 
Loop time of 204.618 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.838 hours/ns, 4.887 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    | 203.65     | 203.65     | 203.65     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14905    | 0.14905    | 0.14905    |   0.0 |  0.07
Output  | 0.00017725 | 0.00017725 | 0.00017725 |   0.0 |  0.00
Modify  | 0.7213     | 0.7213     | 0.7213     |   0.0 |  0.35
Other   |            | 0.101      |            |       |  0.05

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:      314868.0 ave      314868 max      314868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314868
Ave neighs/atom = 78.717000
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
43970.457646458

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0