# 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.8890872895717616*${_u_distance}
variable latticeconst_converted equal 3.8890872895717616*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.88908728957176
Lattice spacing in x,y,z = 3.8890873 3.8890873 3.8890873
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 (38.890873 38.890873 38.890873)
  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 (38.890873 38.890873 38.890873)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Pd

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

kim interactions Pd
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JeongParkDo_2018_PdMo__MO_356501945107_001
pair_coeff * * Pd
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 106.42

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -15478.129   -15478.129       -15640       -15640       313.15       313.15    58822.445    58822.445    2939.3072    2939.3072 
    1000   -15319.199   -15319.199   -15481.387   -15481.387    313.76236    313.76236    59577.918    59577.918    244.13182    244.13182 
Loop time of 186.409 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.780 hours/ns, 5.365 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    | 185.52     | 185.52     | 185.52     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14478    | 0.14478    | 0.14478    |   0.0 |  0.08
Output  | 0.00022564 | 0.00022564 | 0.00022564 |   0.0 |  0.00
Modify  | 0.65399    | 0.65399    | 0.65399    |   0.0 |  0.35
Other   |            | 0.09417    |            |       |  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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -15319.199   -15319.199   -15481.387   -15481.387    313.76236    313.76236    59577.918    59577.918    244.13182    244.13182 
    2000    -15321.26    -15321.26    -15478.43    -15478.43    304.05604    304.05604    59500.283    59500.283    3015.0082    3015.0082 
Loop time of 196.674 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.632 hours/ns, 5.085 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    | 195.78     | 195.78     | 195.78     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14607    | 0.14607    | 0.14607    |   0.0 |  0.07
Output  | 0.00021811 | 0.00021811 | 0.00021811 |   0.0 |  0.00
Modify  | 0.65557    | 0.65557    | 0.65557    |   0.0 |  0.33
Other   |            | 0.09512    |            |       |  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:      312042.0 ave      312042 max      312042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.404 ns/day, 59.469 hours/ns, 4.671 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    | 213.09     | 213.09     | 213.09     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15592    | 0.15592    | 0.15592    |   0.0 |  0.07
Output  | 0.00021509 | 0.00021509 | 0.00021509 |   0.0 |  0.00
Modify  | 0.73673    | 0.73673    | 0.73673    |   0.0 |  0.34
Other   |            | 0.1028     |            |       |  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:      312054.0 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.110 hours/ns, 4.401 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    | 226.12     | 226.12     | 226.12     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16116    | 0.16116    | 0.16116    |   0.0 |  0.07
Output  | 0.00026636 | 0.00026636 | 0.00026636 |   0.0 |  0.00
Modify  | 0.80738    | 0.80738    | 0.80738    |   0.0 |  0.36
Other   |            | 0.1064     |            |       |  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:      312048.0 ave      312048 max      312048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.392 ns/day, 61.249 hours/ns, 4.535 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    | 219.46     | 219.46     | 219.46     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16026    | 0.16026    | 0.16026    |   0.0 |  0.07
Output  | 0.00018025 | 0.00018025 | 0.00018025 |   0.0 |  0.00
Modify  | 0.77417    | 0.77417    | 0.77417    |   0.0 |  0.35
Other   |            | 0.1039     |            |       |  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:      312052.0 ave      312052 max      312052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312052
Ave neighs/atom = 78.013000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 310.782077193408, Press = -655.603555902865
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -15325.015   -15325.015   -15483.769   -15483.769    307.12014    307.12014    59508.709    59508.709    2181.2251    2181.2251 
    6000   -15322.423   -15322.423   -15482.872   -15482.872    310.39989    310.39989    59580.694    59580.694   -134.90828   -134.90828 
Loop time of 214.936 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.402 ns/day, 59.704 hours/ns, 4.653 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    | 213.91     | 213.91     | 213.91     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15573    | 0.15573    | 0.15573    |   0.0 |  0.07
Output  | 0.0001782  | 0.0001782  | 0.0001782  |   0.0 |  0.00
Modify  | 0.76596    | 0.76596    | 0.76596    |   0.0 |  0.36
Other   |            | 0.1033     |            |       |  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:      312060.0 ave      312060 max      312060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312060
Ave neighs/atom = 78.015000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.467367431048, Press = -46.4924102973387
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -15322.423   -15322.423   -15482.872   -15482.872    310.39989    310.39989    59580.694    59580.694   -134.90828   -134.90828 
    7000   -15322.543   -15322.543    -15485.55    -15485.55    315.34736    315.34736    59573.383    59573.383    64.564416    64.564416 
Loop time of 220.812 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.337 hours/ns, 4.529 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    | 219.75     | 219.75     | 219.75     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15959    | 0.15959    | 0.15959    |   0.0 |  0.07
Output  | 0.00023958 | 0.00023958 | 0.00023958 |   0.0 |  0.00
Modify  | 0.80117    | 0.80117    | 0.80117    |   0.0 |  0.36
Other   |            | 0.1042     |            |       |  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:      312052.0 ave      312052 max      312052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312052
Ave neighs/atom = 78.013000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.013037218627, Press = -17.4015192149145
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -15322.543   -15322.543    -15485.55    -15485.55    315.34736    315.34736    59573.383    59573.383    64.564416    64.564416 
    8000   -15323.933   -15323.933   -15487.653   -15487.653     316.7274     316.7274     59580.93     59580.93   -411.84364   -411.84364 
Loop time of 218.921 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.811 hours/ns, 4.568 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    | 217.88     | 217.88     | 217.88     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15785    | 0.15785    | 0.15785    |   0.0 |  0.07
Output  | 0.00018031 | 0.00018031 | 0.00018031 |   0.0 |  0.00
Modify  | 0.78219    | 0.78219    | 0.78219    |   0.0 |  0.36
Other   |            | 0.1033     |            |       |  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:      312024.0 ave      312024 max      312024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312024
Ave neighs/atom = 78.006000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.307001412693, Press = -14.6889679631507
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -15323.933   -15323.933   -15487.653   -15487.653     316.7274     316.7274     59580.93     59580.93   -411.84364   -411.84364 
    9000   -15318.741   -15318.741   -15483.637   -15483.637    319.00137    319.00137    59579.801    59579.801    124.11904    124.11904 
Loop time of 229.164 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.657 hours/ns, 4.364 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    | 228.05     | 228.05     | 228.05     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16611    | 0.16611    | 0.16611    |   0.0 |  0.07
Output  | 0.00018068 | 0.00018068 | 0.00018068 |   0.0 |  0.00
Modify  | 0.83616    | 0.83616    | 0.83616    |   0.0 |  0.36
Other   |            | 0.1076     |            |       |  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:      312038.0 ave      312038 max      312038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312038
Ave neighs/atom = 78.009500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.520869464788, Press = -14.8744495472132
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -15318.741   -15318.741   -15483.637   -15483.637    319.00137    319.00137    59579.801    59579.801    124.11904    124.11904 
   10000   -15323.126   -15323.126   -15484.941   -15484.941     313.0416     313.0416     59539.18     59539.18    1105.3277    1105.3277 
Loop time of 223.095 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.387 ns/day, 61.971 hours/ns, 4.482 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 222.01     | 222.01     | 222.01     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16289    | 0.16289    | 0.16289    |   0.0 |  0.07
Output  | 0.00017713 | 0.00017713 | 0.00017713 |   0.0 |  0.00
Modify  | 0.81563    | 0.81563    | 0.81563    |   0.0 |  0.37
Other   |            | 0.1049     |            |       |  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:      312050.0 ave      312050 max      312050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312050
Ave neighs/atom = 78.012500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.553147985567, Press = -9.33462371036721
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -15323.126   -15323.126   -15484.941   -15484.941     313.0416     313.0416     59539.18     59539.18    1105.3277    1105.3277 
   11000   -15320.771   -15320.771   -15482.967   -15482.967     313.7793     313.7793    59606.705    59606.705   -643.25808   -643.25808 
Loop time of 207.565 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.416 ns/day, 57.657 hours/ns, 4.818 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    | 206.58     | 206.58     | 206.58     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15318    | 0.15318    | 0.15318    |   0.0 |  0.07
Output  | 0.00017886 | 0.00017886 | 0.00017886 |   0.0 |  0.00
Modify  | 0.7322     | 0.7322     | 0.7322     |   0.0 |  0.35
Other   |            | 0.09863    |            |       |  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:      312066.0 ave      312066 max      312066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312066
Ave neighs/atom = 78.016500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.990033821501, Press = -14.0936090806852
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -15320.771   -15320.771   -15482.967   -15482.967     313.7793     313.7793    59606.705    59606.705   -643.25808   -643.25808 
   12000   -15324.519   -15324.519   -15483.264   -15483.264    307.10454    307.10454     59635.39     59635.39   -1836.4066   -1836.4066 
Loop time of 194.387 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 53.996 hours/ns, 5.144 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.48     | 193.48     | 193.48     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14568    | 0.14568    | 0.14568    |   0.0 |  0.07
Output  | 0.00018389 | 0.00018389 | 0.00018389 |   0.0 |  0.00
Modify  | 0.66493    | 0.66493    | 0.66493    |   0.0 |  0.34
Other   |            | 0.09286    |            |       |  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:      311998.0 ave      311998 max      311998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311998
Ave neighs/atom = 77.999500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.970809851495, Press = -10.6760496128121
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -15324.519   -15324.519   -15483.264   -15483.264    307.10454    307.10454     59635.39     59635.39   -1836.4066   -1836.4066 
   13000   -15323.401   -15323.401   -15481.919   -15481.919    306.66243    306.66243    59610.699    59610.699   -767.55243   -767.55243 
Loop time of 213.911 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.404 ns/day, 59.420 hours/ns, 4.675 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    | 212.89     | 212.89     | 212.89     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15616    | 0.15616    | 0.15616    |   0.0 |  0.07
Output  | 0.00017927 | 0.00017927 | 0.00017927 |   0.0 |  0.00
Modify  | 0.76009    | 0.76009    | 0.76009    |   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:      312032.0 ave      312032 max      312032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312032
Ave neighs/atom = 78.008000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.010160986036, Press = -5.87436682175034
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -15323.401   -15323.401   -15481.919   -15481.919    306.66243    306.66243    59610.699    59610.699   -767.55243   -767.55243 
   14000   -15315.834   -15315.834   -15480.249   -15480.249    318.07089    318.07089    59656.604    59656.604   -2039.6649   -2039.6649 
Loop time of 205.534 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.093 hours/ns, 4.865 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.56     | 204.56     | 204.56     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15217    | 0.15217    | 0.15217    |   0.0 |  0.07
Output  | 0.00017949 | 0.00017949 | 0.00017949 |   0.0 |  0.00
Modify  | 0.7213     | 0.7213     | 0.7213     |   0.0 |  0.35
Other   |            | 0.09771    |            |       |  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:      312004.0 ave      312004 max      312004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312004
Ave neighs/atom = 78.001000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.027134282076, Press = -3.23604697843091
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -15315.834   -15315.834   -15480.249   -15480.249    318.07089    318.07089    59656.604    59656.604   -2039.6649   -2039.6649 
   15000   -15325.481   -15325.481   -15486.499   -15486.499    311.49964    311.49964    59593.741    59593.741    -659.5161    -659.5161 
Loop time of 199.134 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.315 hours/ns, 5.022 timesteps/s
100.1% 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.2      | 198.2      | 198.2      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14951    | 0.14951    | 0.14951    |   0.0 |  0.08
Output  | 0.00048706 | 0.00048706 | 0.00048706 |   0.0 |  0.00
Modify  | 0.68629    | 0.68629    | 0.68629    |   0.0 |  0.34
Other   |            | 0.09489    |            |       |  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:      312036.0 ave      312036 max      312036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312036
Ave neighs/atom = 78.009000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.119437044076, Press = -0.466470869671655
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -15325.481   -15325.481   -15486.499   -15486.499    311.49964    311.49964    59593.741    59593.741    -659.5161    -659.5161 
   16000   -15326.444   -15326.444   -15485.158   -15485.158    307.04418    307.04418    59578.497    59578.497   -160.00217   -160.00217 
Loop time of 195.165 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.212 hours/ns, 5.124 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.26     | 194.26     | 194.26     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14663    | 0.14663    | 0.14663    |   0.0 |  0.08
Output  | 0.00018268 | 0.00018268 | 0.00018268 |   0.0 |  0.00
Modify  | 0.66873    | 0.66873    | 0.66873    |   0.0 |  0.34
Other   |            | 0.09326    |            |       |  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:      312044.0 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.980495897229, Press = -0.866305278152733
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -15326.444   -15326.444   -15485.158   -15485.158    307.04418    307.04418    59578.497    59578.497   -160.00217   -160.00217 
   17000   -15321.124   -15321.124    -15486.95    -15486.95    320.80149    320.80149    59555.943    59555.943     377.8559     377.8559 
Loop time of 219.529 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.394 ns/day, 60.980 hours/ns, 4.555 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    | 218.47     | 218.47     | 218.47     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15969    | 0.15969    | 0.15969    |   0.0 |  0.07
Output  | 0.00022962 | 0.00022962 | 0.00022962 |   0.0 |  0.00
Modify  | 0.7911     | 0.7911     | 0.7911     |   0.0 |  0.36
Other   |            | 0.1038     |            |       |  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:      312016.0 ave      312016 max      312016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312016
Ave neighs/atom = 78.004000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.802523433061, Press = -1.71279159464429
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -15321.124   -15321.124    -15486.95    -15486.95    320.80149    320.80149    59555.943    59555.943     377.8559     377.8559 
   18000   -15318.308   -15318.308   -15480.755   -15480.755    314.26541    314.26541    59568.232    59568.232    642.50485    642.50485 
Loop time of 225.258 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.572 hours/ns, 4.439 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    | 224.16     | 224.16     | 224.16     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16354    | 0.16354    | 0.16354    |   0.0 |  0.07
Output  | 0.00017983 | 0.00017983 | 0.00017983 |   0.0 |  0.00
Modify  | 0.82588    | 0.82588    | 0.82588    |   0.0 |  0.37
Other   |            | 0.1067     |            |       |  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:      312056.0 ave      312056 max      312056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312056
Ave neighs/atom = 78.014000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.759098285917, Press = -3.64753553014061
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -15318.308   -15318.308   -15480.755   -15480.755    314.26541    314.26541    59568.232    59568.232    642.50485    642.50485 
   19000   -15324.418   -15324.418   -15487.759   -15487.759    315.99519    315.99519    59559.654    59559.654    267.06775    267.06775 
Loop time of 193.981 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.884 hours/ns, 5.155 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    | 193.08     | 193.08     | 193.08     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14266    | 0.14266    | 0.14266    |   0.0 |  0.07
Output  | 0.00017847 | 0.00017847 | 0.00017847 |   0.0 |  0.00
Modify  | 0.66408    | 0.66408    | 0.66408    |   0.0 |  0.34
Other   |            | 0.09607    |            |       |  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:      312052.0 ave      312052 max      312052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312052
Ave neighs/atom = 78.013000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.845198685339, Press = -5.05713488994098
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -15324.418   -15324.418   -15487.759   -15487.759    315.99519    315.99519    59559.654    59559.654    267.06775    267.06775 
   20000   -15319.136   -15319.136   -15483.713   -15483.713    318.38692    318.38692    59596.499    59596.499   -293.51257   -293.51257 
Loop time of 228.475 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.465 hours/ns, 4.377 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    | 227.36     | 227.36     | 227.36     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16653    | 0.16653    | 0.16653    |   0.0 |  0.07
Output  | 0.00017777 | 0.00017777 | 0.00017777 |   0.0 |  0.00
Modify  | 0.83785    | 0.83785    | 0.83785    |   0.0 |  0.37
Other   |            | 0.1071     |            |       |  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:      312042.0 ave      312042 max      312042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312042
Ave neighs/atom = 78.010500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.896626830594, Press = -4.64402719628485
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -15319.136   -15319.136   -15483.713   -15483.713    318.38692    318.38692    59596.499    59596.499   -293.51257   -293.51257 
   21000   -15326.045   -15326.045   -15486.549   -15486.549    310.50489    310.50489    59567.602    59567.602    105.04178    105.04178 
Loop time of 216.882 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.398 ns/day, 60.245 hours/ns, 4.611 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    | 215.85     | 215.85     | 215.85     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15759    | 0.15759    | 0.15759    |   0.0 |  0.07
Output  | 0.00028073 | 0.00028073 | 0.00028073 |   0.0 |  0.00
Modify  | 0.77426    | 0.77426    | 0.77426    |   0.0 |  0.36
Other   |            | 0.103      |            |       |  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:      312040.0 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.899603423181, Press = -4.98302393581194
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -15326.045   -15326.045   -15486.549   -15486.549    310.50489    310.50489    59567.602    59567.602    105.04178    105.04178 
   22000    -15319.53    -15319.53   -15482.462   -15482.462    315.20434    315.20434    59608.861    59608.861   -603.92967   -603.92967 
Loop time of 194.936 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.149 hours/ns, 5.130 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.03     | 194.03     | 194.03     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14474    | 0.14474    | 0.14474    |   0.0 |  0.07
Output  | 0.00017862 | 0.00017862 | 0.00017862 |   0.0 |  0.00
Modify  | 0.67038    | 0.67038    | 0.67038    |   0.0 |  0.34
Other   |            | 0.095      |            |       |  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:      312042.0 ave      312042 max      312042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312042
Ave neighs/atom = 78.010500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.8877706451, Press = -4.74988256367016
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000    -15319.53    -15319.53   -15482.462   -15482.462    315.20434    315.20434    59608.861    59608.861   -603.92967   -603.92967 
   23000   -15322.784   -15322.784   -15486.752   -15486.752    317.20722    317.20722    59617.975    59617.975   -1475.0652   -1475.0652 
Loop time of 225.28 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.578 hours/ns, 4.439 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    | 224.19     | 224.19     | 224.19     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.162      | 0.162      | 0.162      |   0.0 |  0.07
Output  | 0.00023255 | 0.00023255 | 0.00023255 |   0.0 |  0.00
Modify  | 0.82019    | 0.82019    | 0.82019    |   0.0 |  0.36
Other   |            | 0.1062     |            |       |  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:      312022.0 ave      312022 max      312022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312022
Ave neighs/atom = 78.005500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.897653947402, Press = -3.80324841269617
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -15322.784   -15322.784   -15486.752   -15486.752    317.20722    317.20722    59617.975    59617.975   -1475.0652   -1475.0652 
   24000   -15327.583   -15327.583   -15486.229   -15486.229    306.91234    306.91234    59621.479    59621.479   -1531.3969   -1531.3969 
Loop time of 228.579 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.494 hours/ns, 4.375 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    | 227.47     | 227.47     | 227.47     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16438    | 0.16438    | 0.16438    |   0.0 |  0.07
Output  | 0.00017792 | 0.00017792 | 0.00017792 |   0.0 |  0.00
Modify  | 0.83834    | 0.83834    | 0.83834    |   0.0 |  0.37
Other   |            | 0.1074     |            |       |  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:      312030.0 ave      312030 max      312030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312030
Ave neighs/atom = 78.007500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.854203548149, Press = -2.95243756489104
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -15327.583   -15327.583   -15486.229   -15486.229    306.91234    306.91234    59621.479    59621.479   -1531.3969   -1531.3969 
   25000   -15322.992   -15322.992   -15485.208   -15485.208    313.81853    313.81853    59662.473    59662.473   -2670.5515   -2670.5515 
Loop time of 219.605 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.393 ns/day, 61.001 hours/ns, 4.554 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    | 218.54     | 218.54     | 218.54     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16138    | 0.16138    | 0.16138    |   0.0 |  0.07
Output  | 0.00018114 | 0.00018114 | 0.00018114 |   0.0 |  0.00
Modify  | 0.8001     | 0.8001     | 0.8001     |   0.0 |  0.36
Other   |            | 0.1031     |            |       |  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:      312048.0 ave      312048 max      312048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312048
Ave neighs/atom = 78.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.816328616957, Press = -2.31792301279043
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -15322.992   -15322.992   -15485.208   -15485.208    313.81853    313.81853    59662.473    59662.473   -2670.5515   -2670.5515 
   26000    -15328.02    -15328.02   -15486.039   -15486.039    305.69966    305.69966    59647.929    59647.929   -2436.7389   -2436.7389 
Loop time of 194.621 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.061 hours/ns, 5.138 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.71     | 193.71     | 193.71     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14764    | 0.14764    | 0.14764    |   0.0 |  0.08
Output  | 0.00017817 | 0.00017817 | 0.00017817 |   0.0 |  0.00
Modify  | 0.66932    | 0.66932    | 0.66932    |   0.0 |  0.34
Other   |            | 0.09362    |            |       |  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:      312016.0 ave      312016 max      312016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312016
Ave neighs/atom = 78.004000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.677491466745, Press = -1.67499383980139
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000    -15328.02    -15328.02   -15486.039   -15486.039    305.69966    305.69966    59647.929    59647.929   -2436.7389   -2436.7389 
   27000   -15323.538   -15323.538   -15484.213   -15484.213    310.83613    310.83613    59607.235    59607.235   -795.14842   -795.14842 
Loop time of 223.882 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.386 ns/day, 62.189 hours/ns, 4.467 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    | 222.8      | 222.8      | 222.8      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16182    | 0.16182    | 0.16182    |   0.0 |  0.07
Output  | 0.00028451 | 0.00028451 | 0.00028451 |   0.0 |  0.00
Modify  | 0.81468    | 0.81468    | 0.81468    |   0.0 |  0.36
Other   |            | 0.1053     |            |       |  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:      312046.0 ave      312046 max      312046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312046
Ave neighs/atom = 78.011500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.639957917806, Press = -1.31860954399308
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -15323.538   -15323.538   -15484.213   -15484.213    310.83613    310.83613    59607.235    59607.235   -795.14842   -795.14842 
   28000   -15321.179   -15321.179   -15483.772   -15483.772     314.5468     314.5468    59599.734    59599.734   -623.82437   -623.82437 
Loop time of 210.912 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.410 ns/day, 58.587 hours/ns, 4.741 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    | 209.9      | 209.9      | 209.9      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15528    | 0.15528    | 0.15528    |   0.0 |  0.07
Output  | 0.00018345 | 0.00018345 | 0.00018345 |   0.0 |  0.00
Modify  | 0.75609    | 0.75609    | 0.75609    |   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:      312038.0 ave      312038 max      312038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312038
Ave neighs/atom = 78.009500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.595021139786, Press = -0.224933545474739
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -15321.179   -15321.179   -15483.772   -15483.772     314.5468     314.5468    59599.734    59599.734   -623.82437   -623.82437 
   29000   -15324.633   -15324.633   -15485.672   -15485.672    311.54078    311.54078    59550.172    59550.172    777.02825    777.02825 
Loop time of 199.465 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.407 hours/ns, 5.013 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    | 198.53     | 198.53     | 198.53     |   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.00018003 | 0.00018003 | 0.00018003 |   0.0 |  0.00
Modify  | 0.69172    | 0.69172    | 0.69172    |   0.0 |  0.35
Other   |            | 0.09792    |            |       |  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:      312032.0 ave      312032 max      312032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312032
Ave neighs/atom = 78.008000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.617420198326, Press = -0.515442764231533
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -15324.633   -15324.633   -15485.672   -15485.672    311.54078    311.54078    59550.172    59550.172    777.02825    777.02825 
   30000   -15314.715   -15314.715   -15480.495   -15480.495    320.71319    320.71319    59597.727    59597.727   -151.15625   -151.15625 
Loop time of 221.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.390 ns/day, 61.545 hours/ns, 4.513 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    | 220.5      | 220.5      | 220.5      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16072    | 0.16072    | 0.16072    |   0.0 |  0.07
Output  | 0.00017872 | 0.00017872 | 0.00017872 |   0.0 |  0.00
Modify  | 0.80164    | 0.80164    | 0.80164    |   0.0 |  0.36
Other   |            | 0.1046     |            |       |  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:      312044.0 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.641570381376, Press = -1.55113487155665
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -15314.715   -15314.715   -15480.495   -15480.495    320.71319    320.71319    59597.727    59597.727   -151.15625   -151.15625 
   31000   -15324.009   -15324.009   -15483.478   -15483.478    308.50342    308.50342    59552.205    59552.205    986.42903    986.42903 
Loop time of 209.839 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.412 ns/day, 58.289 hours/ns, 4.766 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    | 208.84     | 208.84     | 208.84     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15617    | 0.15617    | 0.15617    |   0.0 |  0.07
Output  | 0.00018022 | 0.00018022 | 0.00018022 |   0.0 |  0.00
Modify  | 0.74035    | 0.74035    | 0.74035    |   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:      312098.0 ave      312098 max      312098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312098
Ave neighs/atom = 78.024500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.694713267107, Press = -0.948522436773793
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -15324.009   -15324.009   -15483.478   -15483.478    308.50342    308.50342    59552.205    59552.205    986.42903    986.42903 
   32000   -15315.701   -15315.701   -15482.463   -15482.463    322.61177    322.61177    59596.782    59596.782   -311.35125   -311.35125 
Loop time of 230.216 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.375 ns/day, 63.949 hours/ns, 4.344 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    | 229.1      | 229.1      | 229.1      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16713    | 0.16713    | 0.16713    |   0.0 |  0.07
Output  | 0.00023238 | 0.00023238 | 0.00023238 |   0.0 |  0.00
Modify  | 0.84446    | 0.84446    | 0.84446    |   0.0 |  0.37
Other   |            | 0.1078     |            |       |  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:      312040.0 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.710147674769, Press = -0.775932108894098
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -15315.701   -15315.701   -15482.463   -15482.463    322.61177    322.61177    59596.782    59596.782   -311.35125   -311.35125 
   33000   -15328.369   -15328.369   -15486.425   -15486.425    305.77044    305.77044    59542.203    59542.203    819.53487    819.53487 
Loop time of 226.119 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.382 ns/day, 62.811 hours/ns, 4.422 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.02     | 225.02     | 225.02     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16433    | 0.16433    | 0.16433    |   0.0 |  0.07
Output  | 0.00017933 | 0.00017933 | 0.00017933 |   0.0 |  0.00
Modify  | 0.82535    | 0.82535    | 0.82535    |   0.0 |  0.37
Other   |            | 0.106      |            |       |  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:      312046.0 ave      312046 max      312046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312046
Ave neighs/atom = 78.011500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.688454193671, Press = -1.2991783912982
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -15328.369   -15328.369   -15486.425   -15486.425    305.77044    305.77044    59542.203    59542.203    819.53487    819.53487 
   34000   -15321.734   -15321.734   -15487.971   -15487.971    321.59676    321.59676    59500.429    59500.429     2259.638     2259.638 
Loop time of 194.649 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.069 hours/ns, 5.137 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.74     | 193.74     | 193.74     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14639    | 0.14639    | 0.14639    |   0.0 |  0.08
Output  | 0.00017719 | 0.00017719 | 0.00017719 |   0.0 |  0.00
Modify  | 0.67078    | 0.67078    | 0.67078    |   0.0 |  0.34
Other   |            | 0.09464    |            |       |  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:      312028.0 ave      312028 max      312028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312028
Ave neighs/atom = 78.007000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.638845901967, Press = -1.48751987472885
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -15321.734   -15321.734   -15487.971   -15487.971    321.59676    321.59676    59500.429    59500.429     2259.638     2259.638 
   35000    -15320.11    -15320.11   -15484.285   -15484.285    317.60833    317.60833    59513.496    59513.496    2251.8503    2251.8503 
Loop time of 210.059 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.411 ns/day, 58.350 hours/ns, 4.761 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    | 209.06     | 209.06     | 209.06     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1548     | 0.1548     | 0.1548     |   0.0 |  0.07
Output  | 0.00018056 | 0.00018056 | 0.00018056 |   0.0 |  0.00
Modify  | 0.747      | 0.747      | 0.747      |   0.0 |  0.36
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:      312050.0 ave      312050 max      312050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312050
Ave neighs/atom = 78.012500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.612769530376, Press = -1.92255589756481
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000    -15320.11    -15320.11   -15484.285   -15484.285    317.60833    317.60833    59513.496    59513.496    2251.8503    2251.8503 
   36000   -15324.617   -15324.617   -15485.822   -15485.822    311.86285    311.86285    59527.589    59527.589    1404.5947    1404.5947 
Loop time of 210.765 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.410 ns/day, 58.546 hours/ns, 4.745 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    | 209.76     | 209.76     | 209.76     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15497    | 0.15497    | 0.15497    |   0.0 |  0.07
Output  | 0.00023769 | 0.00023769 | 0.00023769 |   0.0 |  0.00
Modify  | 0.75496    | 0.75496    | 0.75496    |   0.0 |  0.36
Other   |            | 0.09946    |            |       |  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:      312046.0 ave      312046 max      312046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312046
Ave neighs/atom = 78.011500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.63006146423, Press = -3.41799440407935
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -15324.617   -15324.617   -15485.822   -15485.822    311.86285    311.86285    59527.589    59527.589    1404.5947    1404.5947 
   37000    -15326.86    -15326.86   -15486.819   -15486.819    309.45271    309.45271    59550.232    59550.232    714.61737    714.61737 
Loop time of 207.578 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.416 ns/day, 57.660 hours/ns, 4.817 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    | 206.59     | 206.59     | 206.59     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15394    | 0.15394    | 0.15394    |   0.0 |  0.07
Output  | 0.00022165 | 0.00022165 | 0.00022165 |   0.0 |  0.00
Modify  | 0.73564    | 0.73564    | 0.73564    |   0.0 |  0.35
Other   |            | 0.09762    |            |       |  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:      312070.0 ave      312070 max      312070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312070
Ave neighs/atom = 78.017500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.593102161304, Press = -1.88373880417619
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000    -15326.86    -15326.86   -15486.819   -15486.819    309.45271    309.45271    59550.232    59550.232    714.61737    714.61737 
   38000    -15319.89    -15319.89   -15484.103   -15484.103    317.68078    317.68078    59568.067    59568.067     488.2468     488.2468 
Loop time of 227.654 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.380 ns/day, 63.237 hours/ns, 4.393 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.55     | 226.55     | 226.55     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16331    | 0.16331    | 0.16331    |   0.0 |  0.07
Output  | 0.00024919 | 0.00024919 | 0.00024919 |   0.0 |  0.00
Modify  | 0.83253    | 0.83253    | 0.83253    |   0.0 |  0.37
Other   |            | 0.1055     |            |       |  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:      312078.0 ave      312078 max      312078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312078
Ave neighs/atom = 78.019500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.522547070641, Press = -1.10752009838808
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000    -15319.89    -15319.89   -15484.103   -15484.103    317.68078    317.68078    59568.067    59568.067     488.2468     488.2468 
   39000   -15323.082   -15323.082   -15485.833   -15485.833    314.85297    314.85297    59534.233    59534.233    1278.7931    1278.7931 
Loop time of 215.285 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.401 ns/day, 59.801 hours/ns, 4.645 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    | 214.26     | 214.26     | 214.26     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15599    | 0.15599    | 0.15599    |   0.0 |  0.07
Output  | 0.00022271 | 0.00022271 | 0.00022271 |   0.0 |  0.00
Modify  | 0.76879    | 0.76879    | 0.76879    |   0.0 |  0.36
Other   |            | 0.1015     |            |       |  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:      312034.0 ave      312034 max      312034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312034
Ave neighs/atom = 78.008500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.523414541086, Press = -1.99306788636416
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -15323.082   -15323.082   -15485.833   -15485.833    314.85297    314.85297    59534.233    59534.233    1278.7931    1278.7931 
   40000   -15323.623   -15323.623   -15484.747   -15484.747     311.7059     311.7059    59584.629    59584.629   -166.00462   -166.00462 
Loop time of 209.801 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.412 ns/day, 58.278 hours/ns, 4.766 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 208.8      | 208.8      | 208.8      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15452    | 0.15452    | 0.15452    |   0.0 |  0.07
Output  | 0.0001821  | 0.0001821  | 0.0001821  |   0.0 |  0.00
Modify  | 0.75075    | 0.75075    | 0.75075    |   0.0 |  0.36
Other   |            | 0.09982    |            |       |  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:      312036.0 ave      312036 max      312036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312036
Ave neighs/atom = 78.009000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.544146701892, Press = -1.89391793317612
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -15323.623   -15323.623   -15484.747   -15484.747     311.7059     311.7059    59584.629    59584.629   -166.00462   -166.00462 
   41000   -15327.051   -15327.051   -15485.668   -15485.668    306.85582    306.85582     59607.88     59607.88   -1216.4895   -1216.4895 
Loop time of 206.202 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.278 hours/ns, 4.850 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    | 205.22     | 205.22     | 205.22     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15492    | 0.15492    | 0.15492    |   0.0 |  0.08
Output  | 0.0004476  | 0.0004476  | 0.0004476  |   0.0 |  0.00
Modify  | 0.73201    | 0.73201    | 0.73201    |   0.0 |  0.35
Other   |            | 0.09862    |            |       |  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:      312048.0 ave      312048 max      312048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312048
Ave neighs/atom = 78.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.552104215024, Press = -1.68348124282374
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -15327.051   -15327.051   -15485.668   -15485.668    306.85582    306.85582     59607.88     59607.88   -1216.4895   -1216.4895 
   42000   -15322.125   -15322.125   -15485.134   -15485.134    315.35137    315.35137    59604.749    59604.749   -887.06597   -887.06597 
Loop time of 212.9 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.406 ns/day, 59.139 hours/ns, 4.697 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    | 211.88     | 211.88     | 211.88     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15689    | 0.15689    | 0.15689    |   0.0 |  0.07
Output  | 0.00023571 | 0.00023571 | 0.00023571 |   0.0 |  0.00
Modify  | 0.75856    | 0.75856    | 0.75856    |   0.0 |  0.36
Other   |            | 0.1033     |            |       |  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:      312040.0 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.5294446061, Press = -1.5594481086088
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -15322.125   -15322.125   -15485.134   -15485.134    315.35137    315.35137    59604.749    59604.749   -887.06597   -887.06597 
   43000   -15327.208   -15327.208   -15484.648   -15484.648     304.5782     304.5782    59603.314    59603.314   -925.99705   -925.99705 
Loop time of 218.002 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.556 hours/ns, 4.587 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    | 216.95     | 216.95     | 216.95     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15937    | 0.15937    | 0.15937    |   0.0 |  0.07
Output  | 0.00021638 | 0.00021638 | 0.00021638 |   0.0 |  0.00
Modify  | 0.78751    | 0.78751    | 0.78751    |   0.0 |  0.36
Other   |            | 0.1037     |            |       |  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:      312010.0 ave      312010 max      312010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312010
Ave neighs/atom = 78.002500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.509646916641, Press = -1.09361232747269
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -15327.208   -15327.208   -15484.648   -15484.648     304.5782     304.5782    59603.314    59603.314   -925.99705   -925.99705 
   44000   -15323.747   -15323.747   -15486.306   -15486.306    314.48236    314.48236    59624.939    59624.939   -1586.1946   -1586.1946 
Loop time of 228.931 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.592 hours/ns, 4.368 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    | 227.82     | 227.82     | 227.82     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16603    | 0.16603    | 0.16603    |   0.0 |  0.07
Output  | 0.00017868 | 0.00017868 | 0.00017868 |   0.0 |  0.00
Modify  | 0.83749    | 0.83749    | 0.83749    |   0.0 |  0.37
Other   |            | 0.1067     |            |       |  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:      312024.0 ave      312024 max      312024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312024
Ave neighs/atom = 78.006000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.499016275067, Press = 0.471900925440932
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -15323.747   -15323.747   -15486.306   -15486.306    314.48236    314.48236    59624.939    59624.939   -1586.1946   -1586.1946 
   45000   -15321.104   -15321.104   -15483.046   -15483.046     313.2884     313.2884    59601.293    59601.293   -675.17801   -675.17801 
Loop time of 228.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.402 hours/ns, 4.381 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    | 227.14     | 227.14     | 227.14     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16383    | 0.16383    | 0.16383    |   0.0 |  0.07
Output  | 0.00018038 | 0.00018038 | 0.00018038 |   0.0 |  0.00
Modify  | 0.83511    | 0.83511    | 0.83511    |   0.0 |  0.37
Other   |            | 0.1067     |            |       |  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:      312028.0 ave      312028 max      312028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312028
Ave neighs/atom = 78.007000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.486892290753, Press = -0.134421775751107
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -15321.104   -15321.104   -15483.046   -15483.046     313.2884     313.2884    59601.293    59601.293   -675.17801   -675.17801 
   46000   -15326.488   -15326.488   -15488.125   -15488.125    312.69632    312.69632    59594.185    59594.185   -1001.0766   -1001.0766 
Loop time of 218.71 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.753 hours/ns, 4.572 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    | 217.66     | 217.66     | 217.66     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16178    | 0.16178    | 0.16178    |   0.0 |  0.07
Output  | 0.00018024 | 0.00018024 | 0.00018024 |   0.0 |  0.00
Modify  | 0.78586    | 0.78586    | 0.78586    |   0.0 |  0.36
Other   |            | 0.1038     |            |       |  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:      312024.0 ave      312024 max      312024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312024
Ave neighs/atom = 78.006000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.455453841211, Press = -0.710731085315822
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -15326.488   -15326.488   -15488.125   -15488.125    312.69632    312.69632    59594.185    59594.185   -1001.0766   -1001.0766 
   47000   -15319.418   -15319.418   -15482.645   -15482.645    315.77297    315.77297    59620.809    59620.809   -1189.6883   -1189.6883 
Loop time of 205.127 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.980 hours/ns, 4.875 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.16     | 204.16     | 204.16     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15152    | 0.15152    | 0.15152    |   0.0 |  0.07
Output  | 0.0001803  | 0.0001803  | 0.0001803  |   0.0 |  0.00
Modify  | 0.7177     | 0.7177     | 0.7177     |   0.0 |  0.35
Other   |            | 0.0986     |            |       |  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:      312040.0 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.451570744514, Press = -1.1538377524062
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -15319.418   -15319.418   -15482.645   -15482.645    315.77297    315.77297    59620.809    59620.809   -1189.6883   -1189.6883 
   48000   -15323.879   -15323.879   -15482.568   -15482.568    306.99475    306.99475    59640.846    59640.846   -1846.7078   -1846.7078 
Loop time of 217.643 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.397 ns/day, 60.456 hours/ns, 4.595 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    | 216.6      | 216.6      | 216.6      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15974    | 0.15974    | 0.15974    |   0.0 |  0.07
Output  | 0.00018001 | 0.00018001 | 0.00018001 |   0.0 |  0.00
Modify  | 0.78176    | 0.78176    | 0.78176    |   0.0 |  0.36
Other   |            | 0.1031     |            |       |  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:      312046.0 ave      312046 max      312046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312046
Ave neighs/atom = 78.011500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.461135220044, Press = -0.811572950422928
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -15323.879   -15323.879   -15482.568   -15482.568    306.99475    306.99475    59640.846    59640.846   -1846.7078   -1846.7078 
   49000   -15321.662   -15321.662   -15484.153   -15484.153    314.35053    314.35053     59634.95     59634.95   -1822.0439   -1822.0439 
Loop time of 226.461 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.382 ns/day, 62.906 hours/ns, 4.416 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.35     | 225.35     | 225.35     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16583    | 0.16583    | 0.16583    |   0.0 |  0.07
Output  | 0.00018154 | 0.00018154 | 0.00018154 |   0.0 |  0.00
Modify  | 0.83858    | 0.83858    | 0.83858    |   0.0 |  0.37
Other   |            | 0.1069     |            |       |  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:      312014.0 ave      312014 max      312014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312014
Ave neighs/atom = 78.003500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.446673719072, Press = -0.911129822493939
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -15321.662   -15321.662   -15484.153   -15484.153    314.35053    314.35053     59634.95     59634.95   -1822.0439   -1822.0439 
   50000    -15317.87    -15317.87   -15483.534   -15483.534      320.488      320.488    59582.981    59582.981    2.8716789    2.8716789 
Loop time of 228.922 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.590 hours/ns, 4.368 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    | 227.81     | 227.81     | 227.81     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16714    | 0.16714    | 0.16714    |   0.0 |  0.07
Output  | 0.00024174 | 0.00024174 | 0.00024174 |   0.0 |  0.00
Modify  | 0.83874    | 0.83874    | 0.83874    |   0.0 |  0.37
Other   |            | 0.1079     |            |       |  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:      312050.0 ave      312050 max      312050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312050
Ave neighs/atom = 78.012500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.463935934312, Press = -1.01188381522999
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000    -15317.87    -15317.87   -15483.534   -15483.534      320.488      320.488    59582.981    59582.981    2.8716789    2.8716789 
   51000   -15325.864   -15325.864   -15489.169   -15489.169    315.92365    315.92365    59571.128    59571.128   -360.80695   -360.80695 
Loop time of 200.206 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.613 hours/ns, 4.995 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    | 199.26     | 199.26     | 199.26     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15127    | 0.15127    | 0.15127    |   0.0 |  0.08
Output  | 0.0002227  | 0.0002227  | 0.0002227  |   0.0 |  0.00
Modify  | 0.69949    | 0.69949    | 0.69949    |   0.0 |  0.35
Other   |            | 0.09698    |            |       |  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:      312012.0 ave      312012 max      312012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312012
Ave neighs/atom = 78.003000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.483622177814, Press = -1.2753661113273
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -15325.864   -15325.864   -15489.169   -15489.169    315.92365    315.92365    59571.128    59571.128   -360.80695   -360.80695 
   52000   -15321.651   -15321.651   -15481.666   -15481.666    309.55946    309.55946    59615.112    59615.112   -849.65986   -849.65986 
Loop time of 211.73 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.408 ns/day, 58.814 hours/ns, 4.723 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    | 210.72     | 210.72     | 210.72     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1548     | 0.1548     | 0.1548     |   0.0 |  0.07
Output  | 0.00017871 | 0.00017871 | 0.00017871 |   0.0 |  0.00
Modify  | 0.7531     | 0.7531     | 0.7531     |   0.0 |  0.36
Other   |            | 0.1022     |            |       |  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:      312056.0 ave      312056 max      312056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312056
Ave neighs/atom = 78.014000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.463654160441, Press = -1.19622667069031
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -15321.651   -15321.651   -15481.666   -15481.666    309.55946    309.55946    59615.112    59615.112   -849.65986   -849.65986 
   53000   -15325.998   -15325.998   -15487.002   -15487.002    311.47213    311.47213    59609.251    59609.251   -1295.3936   -1295.3936 
Loop time of 223.324 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.387 ns/day, 62.034 hours/ns, 4.478 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    | 222.24     | 222.24     | 222.24     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16351    | 0.16351    | 0.16351    |   0.0 |  0.07
Output  | 0.00017944 | 0.00017944 | 0.00017944 |   0.0 |  0.00
Modify  | 0.81756    | 0.81756    | 0.81756    |   0.0 |  0.37
Other   |            | 0.1061     |            |       |  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:      312052.0 ave      312052 max      312052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312052
Ave neighs/atom = 78.013000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.439730108852, Press = -1.46949447571831
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -15325.998   -15325.998   -15487.002   -15487.002    311.47213    311.47213    59609.251    59609.251   -1295.3936   -1295.3936 
   54000   -15322.598   -15322.598    -15485.76    -15485.76    315.64684    315.64684    59609.278    59609.278    -1075.959    -1075.959 
Loop time of 223.596 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.386 ns/day, 62.110 hours/ns, 4.472 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    | 222.51     | 222.51     | 222.51     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16329    | 0.16329    | 0.16329    |   0.0 |  0.07
Output  | 0.0001834  | 0.0001834  | 0.0001834  |   0.0 |  0.00
Modify  | 0.81553    | 0.81553    | 0.81553    |   0.0 |  0.36
Other   |            | 0.1044     |            |       |  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:      312034.0 ave      312034 max      312034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312034
Ave neighs/atom = 78.008500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.429169518068, Press = -0.974097444745433
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -15322.598   -15322.598    -15485.76    -15485.76    315.64684    315.64684    59609.278    59609.278    -1075.959    -1075.959 
   55000   -15323.866   -15323.866   -15485.165   -15485.165    312.04416    312.04416    59585.215    59585.215    -436.8743    -436.8743 
Loop time of 225.729 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.702 hours/ns, 4.430 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    | 224.64     | 224.64     | 224.64     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16296    | 0.16296    | 0.16296    |   0.0 |  0.07
Output  | 0.00024649 | 0.00024649 | 0.00024649 |   0.0 |  0.00
Modify  | 0.82074    | 0.82074    | 0.82074    |   0.0 |  0.36
Other   |            | 0.105      |            |       |  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:      312022.0 ave      312022 max      312022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312022
Ave neighs/atom = 78.005500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.42205744858, Press = -0.726104416808497
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -15323.866   -15323.866   -15485.165   -15485.165    312.04416    312.04416    59585.215    59585.215    -436.8743    -436.8743 
   56000   -15322.732   -15322.732   -15484.272   -15484.272    312.50955    312.50955    59568.243    59568.243    300.22831    300.22831 
Loop time of 216.016 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.400 ns/day, 60.004 hours/ns, 4.629 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 214.98     | 214.98     | 214.98     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16018    | 0.16018    | 0.16018    |   0.0 |  0.07
Output  | 0.0001775  | 0.0001775  | 0.0001775  |   0.0 |  0.00
Modify  | 0.77535    | 0.77535    | 0.77535    |   0.0 |  0.36
Other   |            | 0.1023     |            |       |  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:      312050.0 ave      312050 max      312050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312050
Ave neighs/atom = 78.012500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.43108888681, Press = -0.584145894179609
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -15322.732   -15322.732   -15484.272   -15484.272    312.50955    312.50955    59568.243    59568.243    300.22831    300.22831 
   57000   -15316.515   -15316.515   -15483.649   -15483.649    323.33208    323.33208    59510.936    59510.936    2400.9808    2400.9808 
Loop time of 211.847 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.408 ns/day, 58.846 hours/ns, 4.720 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    | 210.83     | 210.83     | 210.83     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15693    | 0.15693    | 0.15693    |   0.0 |  0.07
Output  | 0.00018043 | 0.00018043 | 0.00018043 |   0.0 |  0.00
Modify  | 0.7578     | 0.7578     | 0.7578     |   0.0 |  0.36
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:      312062.0 ave      312062 max      312062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312062
Ave neighs/atom = 78.015500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.437972071903, Press = -0.286735290217042
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -15316.515   -15316.515   -15483.649   -15483.649    323.33208    323.33208    59510.936    59510.936    2400.9808    2400.9808 
   58000   -15323.779   -15323.779   -15485.799   -15485.799    313.43894    313.43894    59496.111    59496.111    2452.8759    2452.8759 
Loop time of 228.063 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.351 hours/ns, 4.385 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.96     | 226.96     | 226.96     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16433    | 0.16433    | 0.16433    |   0.0 |  0.07
Output  | 0.00022084 | 0.00022084 | 0.00022084 |   0.0 |  0.00
Modify  | 0.83118    | 0.83118    | 0.83118    |   0.0 |  0.36
Other   |            | 0.1066     |            |       |  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:      312042.0 ave      312042 max      312042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312042
Ave neighs/atom = 78.010500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.456323317219, Press = -1.01839026450127
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -15323.779   -15323.779   -15485.799   -15485.799    313.43894    313.43894    59496.111    59496.111    2452.8759    2452.8759 
   59000   -15323.865   -15323.865   -15488.277   -15488.277     318.0661     318.0661    59512.783    59512.783    1696.1954    1696.1954 
Loop time of 225.138 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.538 hours/ns, 4.442 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    | 224.05     | 224.05     | 224.05     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16368    | 0.16368    | 0.16368    |   0.0 |  0.07
Output  | 0.00022465 | 0.00022465 | 0.00022465 |   0.0 |  0.00
Modify  | 0.82027    | 0.82027    | 0.82027    |   0.0 |  0.36
Other   |            | 0.105      |            |       |  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:      312064.0 ave      312064 max      312064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312064
Ave neighs/atom = 78.016000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.462475718321, Press = -1.15333253962045
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -15323.865   -15323.865   -15488.277   -15488.277     318.0661     318.0661    59512.783    59512.783    1696.1954    1696.1954 
   60000   -15320.411   -15320.411   -15484.048   -15484.048      316.567      316.567    59545.582    59545.582    1014.4153    1014.4153 
Loop time of 225.819 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.728 hours/ns, 4.428 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.72     | 224.72     | 224.72     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16461    | 0.16461    | 0.16461    |   0.0 |  0.07
Output  | 0.00023019 | 0.00023019 | 0.00023019 |   0.0 |  0.00
Modify  | 0.83017    | 0.83017    | 0.83017    |   0.0 |  0.37
Other   |            | 0.107      |            |       |  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:      312054.0 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312054
Ave neighs/atom = 78.013500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.454820742139, Press = -1.25394215912265
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -15320.411   -15320.411   -15484.048   -15484.048      316.567      316.567    59545.582    59545.582    1014.4153    1014.4153 
   61000   -15323.998   -15323.998   -15483.513   -15483.513     308.5918     308.5918    59581.195    59581.195   -169.17797   -169.17797 
Loop time of 220.346 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.392 ns/day, 61.207 hours/ns, 4.538 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    | 219.28     | 219.28     | 219.28     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16189    | 0.16189    | 0.16189    |   0.0 |  0.07
Output  | 0.00017943 | 0.00017943 | 0.00017943 |   0.0 |  0.00
Modify  | 0.8016     | 0.8016     | 0.8016     |   0.0 |  0.36
Other   |            | 0.1044     |            |       |  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:      312018.0 ave      312018 max      312018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312018
Ave neighs/atom = 78.004500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.440210568699, Press = -1.09858602410908
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -15323.998   -15323.998   -15483.513   -15483.513     308.5918     308.5918    59581.195    59581.195   -169.17797   -169.17797 
   62000    -15325.35    -15325.35   -15485.715   -15485.715    310.23687    310.23687    59559.132    59559.132    442.58885    442.58885 
Loop time of 212.548 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.406 ns/day, 59.041 hours/ns, 4.705 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    | 211.53     | 211.53     | 211.53     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15637    | 0.15637    | 0.15637    |   0.0 |  0.07
Output  | 0.00017809 | 0.00017809 | 0.00017809 |   0.0 |  0.00
Modify  | 0.75986    | 0.75986    | 0.75986    |   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:      312044.0 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.449758298468, Press = -0.795830291755536
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000    -15325.35    -15325.35   -15485.715   -15485.715    310.23687    310.23687    59559.132    59559.132    442.58885    442.58885 
   63000    -15321.88    -15321.88   -15485.355   -15485.355     316.2545     316.2545    59598.822    59598.822   -862.80853   -862.80853 
Loop time of 226.885 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.381 ns/day, 63.024 hours/ns, 4.408 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    | 225.77     | 225.77     | 225.77     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16737    | 0.16737    | 0.16737    |   0.0 |  0.07
Output  | 0.00022967 | 0.00022967 | 0.00022967 |   0.0 |  0.00
Modify  | 0.83887    | 0.83887    | 0.83887    |   0.0 |  0.37
Other   |            | 0.1078     |            |       |  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:      312022.0 ave      312022 max      312022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312022
Ave neighs/atom = 78.005500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.454198254648, Press = -1.69337732129356
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000    -15321.88    -15321.88   -15485.355   -15485.355     316.2545     316.2545    59598.822    59598.822   -862.80853   -862.80853 
   64000   -15321.935   -15321.935   -15482.778   -15482.778    311.16212    311.16212    59598.097    59598.097   -551.66113   -551.66113 
Loop time of 213.048 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.406 ns/day, 59.180 hours/ns, 4.694 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    | 212.02     | 212.02     | 212.02     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15705    | 0.15705    | 0.15705    |   0.0 |  0.07
Output  | 0.00023456 | 0.00023456 | 0.00023456 |   0.0 |  0.00
Modify  | 0.76652    | 0.76652    | 0.76652    |   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:      312054.0 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312054
Ave neighs/atom = 78.013500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.448747055263, Press = -1.16187452342503
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -15321.935   -15321.935   -15482.778   -15482.778    311.16212    311.16212    59598.097    59598.097   -551.66113   -551.66113 
   65000   -15323.501   -15323.501   -15484.748   -15484.748    311.94321    311.94321    59593.388    59593.388   -549.90335   -549.90335 
Loop time of 228.155 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.376 hours/ns, 4.383 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    | 227.04     | 227.04     | 227.04     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16755    | 0.16755    | 0.16755    |   0.0 |  0.07
Output  | 0.00028246 | 0.00028246 | 0.00028246 |   0.0 |  0.00
Modify  | 0.83666    | 0.83666    | 0.83666    |   0.0 |  0.37
Other   |            | 0.1066     |            |       |  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:      312040.0 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.469631353117, Press = -0.982578394139918
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -15323.501   -15323.501   -15484.748   -15484.748    311.94321    311.94321    59593.388    59593.388   -549.90335   -549.90335 
   66000   -15322.169   -15322.169   -15484.707   -15484.707    314.44027    314.44027    59607.823    59607.823   -973.28807   -973.28807 
Loop time of 224.997 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.499 hours/ns, 4.445 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    | 223.88     | 223.88     | 223.88     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16833    | 0.16833    | 0.16833    |   0.0 |  0.07
Output  | 0.00018222 | 0.00018222 | 0.00018222 |   0.0 |  0.00
Modify  | 0.84246    | 0.84246    | 0.84246    |   0.0 |  0.37
Other   |            | 0.1064     |            |       |  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:      311988.0 ave      311988 max      311988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311988
Ave neighs/atom = 77.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.445732691877, Press = -0.318993337080058
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -15322.169   -15322.169   -15484.707   -15484.707    314.44027    314.44027    59607.823    59607.823   -973.28807   -973.28807 
   67000   -15326.917   -15326.917   -15488.623   -15488.623    312.83196    312.83196    59529.338    59529.338    1084.4707    1084.4707 
Loop time of 199.256 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.349 hours/ns, 5.019 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    | 198.32     | 198.32     | 198.32     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1501     | 0.1501     | 0.1501     |   0.0 |  0.08
Output  | 0.00048508 | 0.00048508 | 0.00048508 |   0.0 |  0.00
Modify  | 0.69138    | 0.69138    | 0.69138    |   0.0 |  0.35
Other   |            | 0.09629    |            |       |  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:      312018.0 ave      312018 max      312018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312018
Ave neighs/atom = 78.004500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.421746284015, Press = -0.0631411941164881
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -15326.917   -15326.917   -15488.623   -15488.623    312.83196    312.83196    59529.338    59529.338    1084.4707    1084.4707 
   68000   -15322.914   -15322.914    -15485.53    -15485.53    314.59162    314.59162    59571.981    59571.981    69.760883    69.760883 
Loop time of 194.817 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.116 hours/ns, 5.133 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    | 193.9      | 193.9      | 193.9      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14878    | 0.14878    | 0.14878    |   0.0 |  0.08
Output  | 0.00018056 | 0.00018056 | 0.00018056 |   0.0 |  0.00
Modify  | 0.66965    | 0.66965    | 0.66965    |   0.0 |  0.34
Other   |            | 0.09353    |            |       |  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:      312064.0 ave      312064 max      312064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312064
Ave neighs/atom = 78.016000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.399144246323, Press = -0.2381938948744
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -15322.914   -15322.914    -15485.53    -15485.53    314.59162    314.59162    59571.981    59571.981    69.760883    69.760883 
   69000   -15325.921   -15325.921   -15487.195   -15487.195    311.99524    311.99524    59576.707    59576.707   -342.21024   -342.21024 
Loop time of 195.161 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.211 hours/ns, 5.124 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    | 194.25     | 194.25     | 194.25     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14863    | 0.14863    | 0.14863    |   0.0 |  0.08
Output  | 0.00017997 | 0.00017997 | 0.00017997 |   0.0 |  0.00
Modify  | 0.67064    | 0.67064    | 0.67064    |   0.0 |  0.34
Other   |            | 0.09418    |            |       |  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:      312040.0 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.394758457265, Press = -0.443116853933176
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -15325.921   -15325.921   -15487.195   -15487.195    311.99524    311.99524    59576.707    59576.707   -342.21024   -342.21024 
   70000   -15320.349   -15320.349   -15482.419   -15482.419    313.53579    313.53579    59550.271    59550.271    1117.1581    1117.1581 
Loop time of 194.969 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.158 hours/ns, 5.129 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    | 194.06     | 194.06     | 194.06     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14706    | 0.14706    | 0.14706    |   0.0 |  0.08
Output  | 0.00018812 | 0.00018812 | 0.00018812 |   0.0 |  0.00
Modify  | 0.67024    | 0.67024    | 0.67024    |   0.0 |  0.34
Other   |            | 0.09438    |            |       |  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:      312052.0 ave      312052 max      312052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312052
Ave neighs/atom = 78.013000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.369942230117, Press = -0.641907426329703
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -15320.349   -15320.349   -15482.419   -15482.419    313.53579    313.53579    59550.271    59550.271    1117.1581    1117.1581 
   71000   -15323.504   -15323.504   -15486.576   -15486.576    315.47337    315.47337    59585.158    59585.158   -439.30516   -439.30516 
Loop time of 195.125 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.201 hours/ns, 5.125 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    | 194.21     | 194.21     | 194.21     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14896    | 0.14896    | 0.14896    |   0.0 |  0.08
Output  | 0.00018127 | 0.00018127 | 0.00018127 |   0.0 |  0.00
Modify  | 0.67034    | 0.67034    | 0.67034    |   0.0 |  0.34
Other   |            | 0.09348    |            |       |  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:      312064.0 ave      312064 max      312064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312064
Ave neighs/atom = 78.016000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.340925122557, Press = -0.575216820582978
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -15323.504   -15323.504   -15486.576   -15486.576    315.47337    315.47337    59585.158    59585.158   -439.30516   -439.30516 
   72000   -15326.221   -15326.221   -15486.707   -15486.707    310.46959    310.46959    59562.844    59562.844    147.41693    147.41693 
Loop time of 214.562 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.403 ns/day, 59.600 hours/ns, 4.661 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    | 213.53     | 213.53     | 213.53     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15931    | 0.15931    | 0.15931    |   0.0 |  0.07
Output  | 0.00017632 | 0.00017632 | 0.00017632 |   0.0 |  0.00
Modify  | 0.76877    | 0.76877    | 0.76877    |   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:      312060.0 ave      312060 max      312060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312060
Ave neighs/atom = 78.015000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.3295121095, Press = -0.544741170873825
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -15326.221   -15326.221   -15486.707   -15486.707    310.46959    310.46959    59562.844    59562.844    147.41693    147.41693 
   73000   -15320.732   -15320.732   -15484.925   -15484.925    317.64118    317.64118     59558.49     59558.49    464.76634    464.76634 
Loop time of 219.196 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.394 ns/day, 60.888 hours/ns, 4.562 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    | 218.14     | 218.14     | 218.14     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16118    | 0.16118    | 0.16118    |   0.0 |  0.07
Output  | 0.00017666 | 0.00017666 | 0.00017666 |   0.0 |  0.00
Modify  | 0.79223    | 0.79223    | 0.79223    |   0.0 |  0.36
Other   |            | 0.1038     |            |       |  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:      312050.0 ave      312050 max      312050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312050
Ave neighs/atom = 78.012500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.329969960838, Press = -1.09060512264638
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -15320.732   -15320.732   -15484.925   -15484.925    317.64118    317.64118     59558.49     59558.49    464.76634    464.76634 
   74000   -15324.383   -15324.383   -15485.445   -15485.445    311.58633    311.58633    59558.792    59558.792    453.15211    453.15211 
Loop time of 226.889 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.381 ns/day, 63.025 hours/ns, 4.407 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    | 225.78     | 225.78     | 225.78     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16531    | 0.16531    | 0.16531    |   0.0 |  0.07
Output  | 0.00022966 | 0.00022966 | 0.00022966 |   0.0 |  0.00
Modify  | 0.83193    | 0.83193    | 0.83193    |   0.0 |  0.37
Other   |            | 0.1067     |            |       |  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:      312042.0 ave      312042 max      312042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312042
Ave neighs/atom = 78.010500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.314825704325, Press = -1.28125689135392
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -15324.383   -15324.383   -15485.445   -15485.445    311.58633    311.58633    59558.792    59558.792    453.15211    453.15211 
   75000   -15321.497   -15321.497   -15484.932   -15484.932    316.17617    316.17617    59540.815    59540.815    1197.7882    1197.7882 
Loop time of 205.725 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.146 hours/ns, 4.861 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.75     | 204.75     | 204.75     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15395    | 0.15395    | 0.15395    |   0.0 |  0.07
Output  | 0.00018202 | 0.00018202 | 0.00018202 |   0.0 |  0.00
Modify  | 0.72446    | 0.72446    | 0.72446    |   0.0 |  0.35
Other   |            | 0.099      |            |       |  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:      312048.0 ave      312048 max      312048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312048
Ave neighs/atom = 78.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.319513777614, Press = -0.934092565205161
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -15321.497   -15321.497   -15484.932   -15484.932    316.17617    316.17617    59540.815    59540.815    1197.7882    1197.7882 
   76000    -15326.06    -15326.06   -15484.909   -15484.909    307.30366    307.30366    59497.792    59497.792     2554.224     2554.224 
Loop time of 214.403 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.403 ns/day, 59.556 hours/ns, 4.664 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    | 213.38     | 213.38     | 213.38     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15697    | 0.15697    | 0.15697    |   0.0 |  0.07
Output  | 0.00018354 | 0.00018354 | 0.00018354 |   0.0 |  0.00
Modify  | 0.76536    | 0.76536    | 0.76536    |   0.0 |  0.36
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:      312018.0 ave      312018 max      312018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312018
Ave neighs/atom = 78.004500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.314278323187, Press = -0.567991569022678
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000    -15326.06    -15326.06   -15484.909   -15484.909    307.30366    307.30366    59497.792    59497.792     2554.224     2554.224 
   77000    -15316.93    -15316.93   -15482.865   -15482.865     321.0142     321.0142    59573.548    59573.548    327.23532    327.23532 
Loop time of 210.603 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.410 ns/day, 58.501 hours/ns, 4.748 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    | 209.6      | 209.6      | 209.6      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15429    | 0.15429    | 0.15429    |   0.0 |  0.07
Output  | 0.00018276 | 0.00018276 | 0.00018276 |   0.0 |  0.00
Modify  | 0.74799    | 0.74799    | 0.74799    |   0.0 |  0.36
Other   |            | 0.1009     |            |       |  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:      312086.0 ave      312086 max      312086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312086
Ave neighs/atom = 78.021500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.31573625802, Press = -0.753132220448727
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000    -15316.93    -15316.93   -15482.865   -15482.865     321.0142     321.0142    59573.548    59573.548    327.23532    327.23532 
   78000    -15322.24    -15322.24   -15483.012   -15483.012    311.02392    311.02392    59625.111    59625.111   -1387.8077   -1387.8077 
Loop time of 196.957 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.710 hours/ns, 5.077 timesteps/s
100.1% 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.04     | 196.04     | 196.04     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1467     | 0.1467     | 0.1467     |   0.0 |  0.07
Output  | 0.00022142 | 0.00022142 | 0.00022142 |   0.0 |  0.00
Modify  | 0.67775    | 0.67775    | 0.67775    |   0.0 |  0.34
Other   |            | 0.09584    |            |       |  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:      312052.0 ave      312052 max      312052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312052
Ave neighs/atom = 78.013000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.327515275268, Press = -0.957255785250365
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000    -15322.24    -15322.24   -15483.012   -15483.012    311.02392    311.02392    59625.111    59625.111   -1387.8077   -1387.8077 
   79000   -15323.628   -15323.628   -15486.579   -15486.579    315.24049    315.24049    59604.963    59604.963   -989.23475   -989.23475 
Loop time of 210.281 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.411 ns/day, 58.411 hours/ns, 4.756 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    | 209.28     | 209.28     | 209.28     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1548     | 0.1548     | 0.1548     |   0.0 |  0.07
Output  | 0.00018099 | 0.00018099 | 0.00018099 |   0.0 |  0.00
Modify  | 0.74645    | 0.74645    | 0.74645    |   0.0 |  0.35
Other   |            | 0.1009     |            |       |  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:      312012.0 ave      312012 max      312012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312012
Ave neighs/atom = 78.003000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.322040446616, Press = -0.888496063649147
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -15323.628   -15323.628   -15486.579   -15486.579    315.24049    315.24049    59604.963    59604.963   -989.23475   -989.23475 
   80000    -15323.29    -15323.29   -15484.763   -15484.763    312.37965    312.37965     59620.17     59620.17   -1403.9376   -1403.9376 
Loop time of 202.136 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.149 hours/ns, 4.947 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    | 201.18     | 201.18     | 201.18     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15164    | 0.15164    | 0.15164    |   0.0 |  0.08
Output  | 0.00022548 | 0.00022548 | 0.00022548 |   0.0 |  0.00
Modify  | 0.70691    | 0.70691    | 0.70691    |   0.0 |  0.35
Other   |            | 0.09849    |            |       |  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:      312006.0 ave      312006 max      312006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312006
Ave neighs/atom = 78.001500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.316223231965, Press = -0.571922774045852
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000    -15323.29    -15323.29   -15484.763   -15484.763    312.37965    312.37965     59620.17     59620.17   -1403.9376   -1403.9376 
   81000   -15320.644   -15320.644   -15486.223   -15486.223    320.32359    320.32359    59589.737    59589.737   -561.39268   -561.39268 
Loop time of 227.204 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.380 ns/day, 63.112 hours/ns, 4.401 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    | 226.11     | 226.11     | 226.11     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16474    | 0.16474    | 0.16474    |   0.0 |  0.07
Output  | 0.00018186 | 0.00018186 | 0.00018186 |   0.0 |  0.00
Modify  | 0.82659    | 0.82659    | 0.82659    |   0.0 |  0.36
Other   |            | 0.1071     |            |       |  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:      312034.0 ave      312034 max      312034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312034
Ave neighs/atom = 78.008500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.332709057217, Press = -0.528874789703704
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -15320.644   -15320.644   -15486.223   -15486.223    320.32359    320.32359    59589.737    59589.737   -561.39268   -561.39268 
   82000   -15320.184   -15320.184   -15481.133   -15481.133    311.36697    311.36697    59625.422    59625.422   -984.85821   -984.85821 
Loop time of 210.265 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.411 ns/day, 58.407 hours/ns, 4.756 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    | 209.26     | 209.26     | 209.26     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15273    | 0.15273    | 0.15273    |   0.0 |  0.07
Output  | 0.00017958 | 0.00017958 | 0.00017958 |   0.0 |  0.00
Modify  | 0.74775    | 0.74775    | 0.74775    |   0.0 |  0.36
Other   |            | 0.1015     |            |       |  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:      312050.0 ave      312050 max      312050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312050
Ave neighs/atom = 78.012500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.340427150809, Press = -0.238768653074597
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -15320.184   -15320.184   -15481.133   -15481.133    311.36697    311.36697    59625.422    59625.422   -984.85821   -984.85821 
   83000   -15325.379   -15325.379    -15487.35    -15487.35    313.34326    313.34326    59614.122    59614.122   -1487.8787   -1487.8787 
Loop time of 215.101 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.402 ns/day, 59.750 hours/ns, 4.649 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    | 214.06     | 214.06     | 214.06     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15777    | 0.15777    | 0.15777    |   0.0 |  0.07
Output  | 0.00028476 | 0.00028476 | 0.00028476 |   0.0 |  0.00
Modify  | 0.77662    | 0.77662    | 0.77662    |   0.0 |  0.36
Other   |            | 0.1037     |            |       |  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:      312036.0 ave      312036 max      312036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312036
Ave neighs/atom = 78.009000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.363053965459, Press = -0.403679186432209
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -15325.379   -15325.379    -15487.35    -15487.35    313.34326    313.34326    59614.122    59614.122   -1487.8787   -1487.8787 
   84000   -15319.064   -15319.064   -15479.863   -15479.863    311.07759    311.07759    59582.606    59582.606    418.41746    418.41746 
Loop time of 202.58 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.272 hours/ns, 4.936 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    | 201.62     | 201.62     | 201.62     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15018    | 0.15018    | 0.15018    |   0.0 |  0.07
Output  | 0.00023908 | 0.00023908 | 0.00023908 |   0.0 |  0.00
Modify  | 0.70719    | 0.70719    | 0.70719    |   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:      312040.0 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.362657152199, Press = -0.375144739395242
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -15319.064   -15319.064   -15479.863   -15479.863    311.07759    311.07759    59582.606    59582.606    418.41746    418.41746 
   85000   -15324.558   -15324.558   -15486.587   -15486.587    313.45611    313.45611    59542.821    59542.821    923.67504    923.67504 
Loop time of 218.496 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.693 hours/ns, 4.577 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    | 217.44     | 217.44     | 217.44     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15873    | 0.15873    | 0.15873    |   0.0 |  0.07
Output  | 0.00018059 | 0.00018059 | 0.00018059 |   0.0 |  0.00
Modify  | 0.79038    | 0.79038    | 0.79038    |   0.0 |  0.36
Other   |            | 0.1042     |            |       |  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:      312052.0 ave      312052 max      312052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312052
Ave neighs/atom = 78.013000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.373074380322, Press = -0.190982961397033
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -15324.558   -15324.558   -15486.587   -15486.587    313.45611    313.45611    59542.821    59542.821    923.67504    923.67504 
   86000   -15318.895   -15318.895   -15482.816   -15482.816    317.11599    317.11599    59525.187    59525.187    1976.1841    1976.1841 
Loop time of 221.08 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.411 hours/ns, 4.523 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    | 220.02     | 220.02     | 220.02     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15969    | 0.15969    | 0.15969    |   0.0 |  0.07
Output  | 0.00025041 | 0.00025041 | 0.00025041 |   0.0 |  0.00
Modify  | 0.79547    | 0.79547    | 0.79547    |   0.0 |  0.36
Other   |            | 0.1045     |            |       |  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:      312048.0 ave      312048 max      312048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312048
Ave neighs/atom = 78.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.384706871486, Press = -0.515639307550552
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -15318.895   -15318.895   -15482.816   -15482.816    317.11599    317.11599    59525.187    59525.187    1976.1841    1976.1841 
   87000   -15323.501   -15323.501   -15487.972   -15487.972    318.17848    318.17848    59568.403    59568.403    -62.92727    -62.92727 
Loop time of 202.992 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.387 hours/ns, 4.926 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    | 202.03     | 202.03     | 202.03     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15032    | 0.15032    | 0.15032    |   0.0 |  0.07
Output  | 0.00017948 | 0.00017948 | 0.00017948 |   0.0 |  0.00
Modify  | 0.70974    | 0.70974    | 0.70974    |   0.0 |  0.35
Other   |            | 0.09783    |            |       |  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:      312044.0 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.38878266405, Press = -0.697341505983539
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -15323.501   -15323.501   -15487.972   -15487.972    318.17848    318.17848    59568.403    59568.403    -62.92727    -62.92727 
   88000   -15325.856   -15325.856   -15485.561   -15485.561       308.96       308.96    59556.614    59556.614    547.36136    547.36136 
Loop time of 213.179 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.405 ns/day, 59.216 hours/ns, 4.691 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    | 212.16     | 212.16     | 212.16     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1558     | 0.1558     | 0.1558     |   0.0 |  0.07
Output  | 0.00018133 | 0.00018133 | 0.00018133 |   0.0 |  0.00
Modify  | 0.76032    | 0.76032    | 0.76032    |   0.0 |  0.36
Other   |            | 0.1029     |            |       |  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:      312026.0 ave      312026 max      312026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312026
Ave neighs/atom = 78.006500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.397561064382, Press = -0.820710930546759
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -15325.856   -15325.856   -15485.561   -15485.561       308.96       308.96    59556.614    59556.614    547.36136    547.36136 
   89000   -15321.638   -15321.638    -15481.56    -15481.56    309.38072    309.38072    59547.395    59547.395    1337.0296    1337.0296 
Loop time of 194.117 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.921 hours/ns, 5.152 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.21     | 193.21     | 193.21     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14508    | 0.14508    | 0.14508    |   0.0 |  0.07
Output  | 0.00018346 | 0.00018346 | 0.00018346 |   0.0 |  0.00
Modify  | 0.6645     | 0.6645     | 0.6645     |   0.0 |  0.34
Other   |            | 0.09445    |            |       |  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:      312054.0 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312054
Ave neighs/atom = 78.013500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.372071293975, Press = -0.512853012605049
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -15321.638   -15321.638    -15481.56    -15481.56    309.38072    309.38072    59547.395    59547.395    1337.0296    1337.0296 
   90000   -15322.185   -15322.185   -15483.097   -15483.097    311.29516    311.29516     59560.12     59560.12    639.56463    639.56463 
Loop time of 217.86 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.397 ns/day, 60.517 hours/ns, 4.590 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    | 216.82     | 216.82     | 216.82     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15801    | 0.15801    | 0.15801    |   0.0 |  0.07
Output  | 0.00022078 | 0.00022078 | 0.00022078 |   0.0 |  0.00
Modify  | 0.78279    | 0.78279    | 0.78279    |   0.0 |  0.36
Other   |            | 0.1034     |            |       |  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:      312044.0 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.368723912345, Press = -0.476364457624685
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -15322.185   -15322.185   -15483.097   -15483.097    311.29516    311.29516     59560.12     59560.12    639.56463    639.56463 
   91000    -15325.17    -15325.17    -15484.99    -15484.99    309.18308    309.18308     59491.85     59491.85    2616.9517    2616.9517 
Loop time of 219.388 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.394 ns/day, 60.941 hours/ns, 4.558 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    | 218.33     | 218.33     | 218.33     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16014    | 0.16014    | 0.16014    |   0.0 |  0.07
Output  | 0.00017975 | 0.00017975 | 0.00017975 |   0.0 |  0.00
Modify  | 0.79366    | 0.79366    | 0.79366    |   0.0 |  0.36
Other   |            | 0.1046     |            |       |  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:      312054.0 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312054
Ave neighs/atom = 78.013500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.346431787642, Press = -0.396717820530005
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000    -15325.17    -15325.17    -15484.99    -15484.99    309.18308    309.18308     59491.85     59491.85    2616.9517    2616.9517 
   92000   -15324.849   -15324.849   -15486.895   -15486.895    313.49025    313.49025    59528.635    59528.635     1226.316     1226.316 
Loop time of 228.69 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.525 hours/ns, 4.373 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    | 227.58     | 227.58     | 227.58     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16438    | 0.16438    | 0.16438    |   0.0 |  0.07
Output  | 0.0001776  | 0.0001776  | 0.0001776  |   0.0 |  0.00
Modify  | 0.83872    | 0.83872    | 0.83872    |   0.0 |  0.37
Other   |            | 0.1081     |            |       |  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:      312084.0 ave      312084 max      312084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312084
Ave neighs/atom = 78.021000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.352900959498, Press = -0.857316806410436
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -15324.849   -15324.849   -15486.895   -15486.895    313.49025    313.49025    59528.635    59528.635     1226.316     1226.316 
   93000   -15323.415   -15323.415   -15484.338   -15484.338    311.31602    311.31602    59627.329    59627.329   -1528.4441   -1528.4441 
Loop time of 227.799 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.278 hours/ns, 4.390 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.68     | 226.68     | 226.68     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16317    | 0.16317    | 0.16317    |   0.0 |  0.07
Output  | 0.00017947 | 0.00017947 | 0.00017947 |   0.0 |  0.00
Modify  | 0.84277    | 0.84277    | 0.84277    |   0.0 |  0.37
Other   |            | 0.1089     |            |       |  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:      312058.0 ave      312058 max      312058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312058
Ave neighs/atom = 78.014500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.341564583994, Press = -1.03775595403211
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -15323.415   -15323.415   -15484.338   -15484.338    311.31602    311.31602    59627.329    59627.329   -1528.4441   -1528.4441 
   94000   -15327.581   -15327.581    -15488.04    -15488.04    310.41875    310.41875     59602.25     59602.25   -1259.9094   -1259.9094 
Loop time of 227.46 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.380 ns/day, 63.183 hours/ns, 4.396 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.36     | 226.36     | 226.36     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16142    | 0.16142    | 0.16142    |   0.0 |  0.07
Output  | 0.00017978 | 0.00017978 | 0.00017978 |   0.0 |  0.00
Modify  | 0.832      | 0.832      | 0.832      |   0.0 |  0.37
Other   |            | 0.1079     |            |       |  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:      312036.0 ave      312036 max      312036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312036
Ave neighs/atom = 78.009000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.33516921156, Press = -0.684925840858558
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -15327.581   -15327.581    -15488.04    -15488.04    310.41875    310.41875     59602.25     59602.25   -1259.9094   -1259.9094 
   95000   -15323.491   -15323.491   -15484.547   -15484.547    311.57339    311.57339     59614.08     59614.08   -1163.4608   -1163.4608 
Loop time of 228.473 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.465 hours/ns, 4.377 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    | 227.36     | 227.36     | 227.36     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1643     | 0.1643     | 0.1643     |   0.0 |  0.07
Output  | 0.00018086 | 0.00018086 | 0.00018086 |   0.0 |  0.00
Modify  | 0.83997    | 0.83997    | 0.83997    |   0.0 |  0.37
Other   |            | 0.1079     |            |       |  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:      312026.0 ave      312026 max      312026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312026
Ave neighs/atom = 78.006500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.317724927864, Press = -0.534610036272132
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -15323.491   -15323.491   -15484.547   -15484.547    311.57339    311.57339     59614.08     59614.08   -1163.4608   -1163.4608 
   96000   -15322.379   -15322.379   -15482.549   -15482.549    309.86014    309.86014    59587.524    59587.524   -69.078955   -69.078955 
Loop time of 229.092 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.637 hours/ns, 4.365 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    | 227.98     | 227.98     | 227.98     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16349    | 0.16349    | 0.16349    |   0.0 |  0.07
Output  | 0.0001791  | 0.0001791  | 0.0001791  |   0.0 |  0.00
Modify  | 0.84433    | 0.84433    | 0.84433    |   0.0 |  0.37
Other   |            | 0.1084     |            |       |  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:      312032.0 ave      312032 max      312032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312032
Ave neighs/atom = 78.008000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.31496412056, Press = -0.66789705101296
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -15322.379   -15322.379   -15482.549   -15482.549    309.86014    309.86014    59587.524    59587.524   -69.078955   -69.078955 
   97000    -15326.52    -15326.52   -15485.352   -15485.352    307.27155    307.27155    59588.011    59588.011   -481.44044   -481.44044 
Loop time of 228.842 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.567 hours/ns, 4.370 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    | 227.73     | 227.73     | 227.73     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1642     | 0.1642     | 0.1642     |   0.0 |  0.07
Output  | 0.0001804  | 0.0001804  | 0.0001804  |   0.0 |  0.00
Modify  | 0.83767    | 0.83767    | 0.83767    |   0.0 |  0.37
Other   |            | 0.1086     |            |       |  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:      312048.0 ave      312048 max      312048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312048
Ave neighs/atom = 78.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.29202498194, Press = -0.515321030328905
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000    -15326.52    -15326.52   -15485.352   -15485.352    307.27155    307.27155    59588.011    59588.011   -481.44044   -481.44044 
   98000   -15324.924   -15324.924   -15485.558   -15485.558    310.75804    310.75804    59576.117    59576.117   -65.612334   -65.612334 
Loop time of 229.297 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.693 hours/ns, 4.361 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    | 228.18     | 228.18     | 228.18     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16508    | 0.16508    | 0.16508    |   0.0 |  0.07
Output  | 0.00017905 | 0.00017905 | 0.00017905 |   0.0 |  0.00
Modify  | 0.83895    | 0.83895    | 0.83895    |   0.0 |  0.37
Other   |            | 0.1095     |            |       |  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:      312034.0 ave      312034 max      312034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312034
Ave neighs/atom = 78.008500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.283408259372, Press = -0.50791674771837
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -15324.924   -15324.924   -15485.558   -15485.558    310.75804    310.75804    59576.117    59576.117   -65.612334   -65.612334 
   99000   -15319.863   -15319.863   -15483.671   -15483.671    316.89829    316.89829    59566.648    59566.648    361.98695    361.98695 
Loop time of 228.736 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.538 hours/ns, 4.372 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    | 227.63     | 227.63     | 227.63     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16378    | 0.16378    | 0.16378    |   0.0 |  0.07
Output  | 0.00024561 | 0.00024561 | 0.00024561 |   0.0 |  0.00
Modify  | 0.82966    | 0.82966    | 0.82966    |   0.0 |  0.36
Other   |            | 0.1082     |            |       |  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:      312054.0 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312054
Ave neighs/atom = 78.013500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.255641055182, Press = -0.232376738408414
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -15319.863   -15319.863   -15483.671   -15483.671    316.89829    316.89829    59566.648    59566.648    361.98695    361.98695 
  100000   -15324.651   -15324.651   -15484.828   -15484.828    309.87383    309.87383    59586.813    59586.813    -406.0408    -406.0408 
Loop time of 228.633 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.509 hours/ns, 4.374 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    | 227.52     | 227.52     | 227.52     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16438    | 0.16438    | 0.16438    |   0.0 |  0.07
Output  | 0.00017801 | 0.00017801 | 0.00017801 |   0.0 |  0.00
Modify  | 0.83716    | 0.83716    | 0.83716    |   0.0 |  0.37
Other   |            | 0.1077     |            |       |  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:      312016.0 ave      312016 max      312016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312016
Ave neighs/atom = 78.004000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.269171327264, Press = -0.528323234086552
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -15324.651   -15324.651   -15484.828   -15484.828    309.87383    309.87383    59586.813    59586.813    -406.0408    -406.0408 
  101000   -15321.071   -15321.071   -15483.057   -15483.057    313.37358    313.37358    59609.768    59609.768   -860.74288   -860.74288 
Loop time of 228.265 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.407 hours/ns, 4.381 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.15     | 227.15     | 227.15     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16356    | 0.16356    | 0.16356    |   0.0 |  0.07
Output  | 0.00017814 | 0.00017814 | 0.00017814 |   0.0 |  0.00
Modify  | 0.84348    | 0.84348    | 0.84348    |   0.0 |  0.37
Other   |            | 0.1073     |            |       |  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:      312036.0 ave      312036 max      312036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312036
Ave neighs/atom = 78.009000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.290095135368, Press = -0.498172114676646
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -15321.071   -15321.071   -15483.057   -15483.057    313.37358    313.37358    59609.768    59609.768   -860.74288   -860.74288 
  102000   -15320.317   -15320.317    -15480.49    -15480.49    309.86572    309.86572    59634.567    59634.567   -1275.2271   -1275.2271 
Loop time of 208.209 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.415 ns/day, 57.836 hours/ns, 4.803 timesteps/s
100.1% 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.22     | 207.22     | 207.22     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15257    | 0.15257    | 0.15257    |   0.0 |  0.07
Output  | 0.00022042 | 0.00022042 | 0.00022042 |   0.0 |  0.00
Modify  | 0.73256    | 0.73256    | 0.73256    |   0.0 |  0.35
Other   |            | 0.09918    |            |       |  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:      312036.0 ave      312036 max      312036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0