# 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.5577528923749933*${_u_distance}
variable latticeconst_converted equal 3.5577528923749933*1
lattice       diamond  ${latticeconst_converted}
lattice       diamond  3.55775289237499
Lattice spacing in x,y,z = 3.5577529 3.5577529 3.5577529
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (35.577529 35.577529 35.577529)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 8000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (35.577529 35.577529 35.577529)
  create_atoms CPU = 0.003 seconds

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

kim_interactions C

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

kim interactions C
#=== BEGIN kim interactions ==================================
pair_style kim Tersoff_LAMMPS_AlbeNordlundAverback_2002_PtC__MO_500121566391_004
pair_coeff * * C
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 12.0107

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 45032.6330876461 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_500121566391_004#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 = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.71 | 12.71 | 12.71 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -58261.946   -58261.946   -58585.729   -58585.729       313.15       313.15    45032.633    45032.633    7679.6348    7679.6348 
    1000   -57909.167   -57909.167   -58228.572   -58228.572    308.91653    308.91653    45189.726    45189.726    2970.2744    2970.2744 
Loop time of 127.961 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.675 ns/day, 35.545 hours/ns, 7.815 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    | 127.12     | 127.12     | 127.12     |   0.0 | 99.34
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083071   | 0.083071   | 0.083071   |   0.0 |  0.06
Output  | 0.00022556 | 0.00022556 | 0.00022556 |   0.0 |  0.00
Modify  | 0.67011    | 0.67011    | 0.67011    |   0.0 |  0.52
Other   |            | 0.09077    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      976000.0 ave      976000 max      976000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 976000
Ave neighs/atom = 122.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -57909.167   -57909.167   -58228.572   -58228.572    308.91653    308.91653    45189.726    45189.726    2970.2744    2970.2744 
    2000   -57942.474   -57942.474   -58249.732   -58249.732    297.16792    297.16792    45206.607    45206.607    769.82796    769.82796 
Loop time of 124.178 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.696 ns/day, 34.494 hours/ns, 8.053 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    | 123.34     | 123.34     | 123.34     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.087576   | 0.087576   | 0.087576   |   0.0 |  0.07
Output  | 0.00018119 | 0.00018119 | 0.00018119 |   0.0 |  0.00
Modify  | 0.66356    | 0.66356    | 0.66356    |   0.0 |  0.53
Other   |            | 0.08879    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8929.00 ave        8929 max        8929 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921092.0 ave      921092 max      921092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921092
Ave neighs/atom = 115.13650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -57942.474   -57942.474   -58249.732   -58249.732    297.16792    297.16792    45206.607    45206.607    769.82796    769.82796 
    3000   -57928.658   -57928.658    -58249.66    -58249.66    310.46141    310.46141    45228.532    45228.532    -2375.541    -2375.541 
Loop time of 124.174 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.696 ns/day, 34.493 hours/ns, 8.053 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    | 123.34     | 123.34     | 123.34     |   0.0 | 99.33
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084322   | 0.084322   | 0.084322   |   0.0 |  0.07
Output  | 0.00020238 | 0.00020238 | 0.00020238 |   0.0 |  0.00
Modify  | 0.66503    | 0.66503    | 0.66503    |   0.0 |  0.54
Other   |            | 0.08837    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8856.00 ave        8856 max        8856 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921586.0 ave      921586 max      921586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921586
Ave neighs/atom = 115.19825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -57928.658   -57928.658    -58249.66    -58249.66    310.46141    310.46141    45228.532    45228.532    -2375.541    -2375.541 
    4000   -57931.584   -57931.584   -58263.031   -58263.031    320.56367    320.56367    45234.622    45234.622   -2124.2394   -2124.2394 
Loop time of 124.027 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.697 ns/day, 34.452 hours/ns, 8.063 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    | 123.19     | 123.19     | 123.19     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084573   | 0.084573   | 0.084573   |   0.0 |  0.07
Output  | 0.00016656 | 0.00016656 | 0.00016656 |   0.0 |  0.00
Modify  | 0.66408    | 0.66408    | 0.66408    |   0.0 |  0.54
Other   |            | 0.08866    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8889.00 ave        8889 max        8889 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      919438.0 ave      919438 max      919438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 919438
Ave neighs/atom = 114.92975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -57931.584   -57931.584   -58263.031   -58263.031    320.56367    320.56367    45234.622    45234.622   -2124.2394   -2124.2394 
    5000   -57936.474   -57936.474   -58252.824   -58252.824     305.9622     305.9622    45241.593    45241.593   -3248.3049   -3248.3049 
Loop time of 124.18 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.696 ns/day, 34.495 hours/ns, 8.053 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    | 123.34     | 123.34     | 123.34     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084299   | 0.084299   | 0.084299   |   0.0 |  0.07
Output  | 0.00014786 | 0.00014786 | 0.00014786 |   0.0 |  0.00
Modify  | 0.66651    | 0.66651    | 0.66651    |   0.0 |  0.54
Other   |            | 0.08856    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8852.00 ave        8852 max        8852 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921498.0 ave      921498 max      921498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921498
Ave neighs/atom = 115.18725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.788263125594, Press = 1515.69201948593
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -57936.474   -57936.474   -58252.824   -58252.824     305.9622     305.9622    45241.593    45241.593   -3248.3049   -3248.3049 
    6000   -57926.575   -57926.575   -58256.503   -58256.503    319.09378    319.09378    45220.952    45220.952   -673.54209   -673.54209 
Loop time of 124.039 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.697 ns/day, 34.455 hours/ns, 8.062 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    | 123.19     | 123.19     | 123.19     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083557   | 0.083557   | 0.083557   |   0.0 |  0.07
Output  | 0.00013691 | 0.00013691 | 0.00013691 |   0.0 |  0.00
Modify  | 0.67917    | 0.67917    | 0.67917    |   0.0 |  0.55
Other   |            | 0.08848    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8799.00 ave        8799 max        8799 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920432.0 ave      920432 max      920432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920432
Ave neighs/atom = 115.05400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.725419454105, Press = 191.927450720859
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -57926.575   -57926.575   -58256.503   -58256.503    319.09378    319.09378    45220.952    45220.952   -673.54209   -673.54209 
    7000   -57938.225   -57938.225   -58258.934   -58258.934      310.178      310.178    45198.581    45198.581    868.08382    868.08382 
Loop time of 124.044 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.697 ns/day, 34.457 hours/ns, 8.062 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    | 123.19     | 123.19     | 123.19     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08418    | 0.08418    | 0.08418    |   0.0 |  0.07
Output  | 0.00013553 | 0.00013553 | 0.00013553 |   0.0 |  0.00
Modify  | 0.67907    | 0.67907    | 0.67907    |   0.0 |  0.55
Other   |            | 0.08891    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8811.00 ave        8811 max        8811 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921128.0 ave      921128 max      921128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921128
Ave neighs/atom = 115.14100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.994802032124, Press = 67.4022326061068
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -57938.225   -57938.225   -58258.934   -58258.934      310.178      310.178    45198.581    45198.581    868.08382    868.08382 
    8000   -57928.078   -57928.078   -58258.064   -58258.064    319.15041    319.15041     45196.52     45196.52     2076.135     2076.135 
Loop time of 124.155 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.696 ns/day, 34.487 hours/ns, 8.054 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    | 123.3      | 123.3      | 123.3      |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084228   | 0.084228   | 0.084228   |   0.0 |  0.07
Output  | 0.00014933 | 0.00014933 | 0.00014933 |   0.0 |  0.00
Modify  | 0.67962    | 0.67962    | 0.67962    |   0.0 |  0.55
Other   |            | 0.08859    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8890.00 ave        8890 max        8890 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921910.0 ave      921910 max      921910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921910
Ave neighs/atom = 115.23875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.087115923904, Press = 33.2074293864119
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -57928.078   -57928.078   -58258.064   -58258.064    319.15041    319.15041     45196.52     45196.52     2076.135     2076.135 
    9000   -57934.215   -57934.215   -58255.743   -58255.743    310.97065    310.97065    45194.258    45194.258    1696.1248    1696.1248 
Loop time of 124.328 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.695 ns/day, 34.536 hours/ns, 8.043 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    | 123.47     | 123.47     | 123.47     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084443   | 0.084443   | 0.084443   |   0.0 |  0.07
Output  | 0.00013831 | 0.00013831 | 0.00013831 |   0.0 |  0.00
Modify  | 0.68182    | 0.68182    | 0.68182    |   0.0 |  0.55
Other   |            | 0.08878    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8834.00 ave        8834 max        8834 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      923340.0 ave      923340 max      923340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 923340
Ave neighs/atom = 115.41750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.029663717159, Press = 20.381132382488
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -57934.215   -57934.215   -58255.743   -58255.743    310.97065    310.97065    45194.258    45194.258    1696.1248    1696.1248 
   10000   -57935.042   -57935.042   -58257.585   -58257.585    311.95154    311.95154    45197.022    45197.022    1493.8599    1493.8599 
Loop time of 124.11 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.696 ns/day, 34.475 hours/ns, 8.057 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    | 123.26     | 123.26     | 123.26     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084218   | 0.084218   | 0.084218   |   0.0 |  0.07
Output  | 0.00014804 | 0.00014804 | 0.00014804 |   0.0 |  0.00
Modify  | 0.67967    | 0.67967    | 0.67967    |   0.0 |  0.55
Other   |            | 0.08899    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8868.00 ave        8868 max        8868 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922050.0 ave      922050 max      922050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922050
Ave neighs/atom = 115.25625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.119979601468, Press = 7.16069650877778
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -57935.042   -57935.042   -58257.585   -58257.585    311.95154    311.95154    45197.022    45197.022    1493.8599    1493.8599 
   11000   -57926.535   -57926.535    -58255.46    -58255.46    318.12351    318.12351    45227.374    45227.374   -1704.0096   -1704.0096 
Loop time of 124.26 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.695 ns/day, 34.517 hours/ns, 8.048 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    | 123.41     | 123.41     | 123.41     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084176   | 0.084176   | 0.084176   |   0.0 |  0.07
Output  | 0.00014787 | 0.00014787 | 0.00014787 |   0.0 |  0.00
Modify  | 0.68047    | 0.68047    | 0.68047    |   0.0 |  0.55
Other   |            | 0.08871    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8860.00 ave        8860 max        8860 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922948.0 ave      922948 max      922948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922948
Ave neighs/atom = 115.36850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.072764261158, Press = -3.38466596333741
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -57926.535   -57926.535    -58255.46    -58255.46    318.12351    318.12351    45227.374    45227.374   -1704.0096   -1704.0096 
   12000   -57936.955   -57936.955   -58259.719   -58259.719    312.16619    312.16619    45242.065    45242.065   -3707.3771   -3707.3771 
Loop time of 124.031 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.697 ns/day, 34.453 hours/ns, 8.063 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    | 123.18     | 123.18     | 123.18     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08413    | 0.08413    | 0.08413    |   0.0 |  0.07
Output  | 0.00013648 | 0.00013648 | 0.00013648 |   0.0 |  0.00
Modify  | 0.67963    | 0.67963    | 0.67963    |   0.0 |  0.55
Other   |            | 0.0887     |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8831.00 ave        8831 max        8831 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920594.0 ave      920594 max      920594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920594
Ave neighs/atom = 115.07425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.127234013505, Press = 6.87961335080836
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -57936.955   -57936.955   -58259.719   -58259.719    312.16619    312.16619    45242.065    45242.065   -3707.3771   -3707.3771 
   13000   -57927.313   -57927.313   -58254.718   -58254.718    316.65419    316.65419    45223.014    45223.014   -1072.0489   -1072.0489 
Loop time of 123.476 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.700 ns/day, 34.299 hours/ns, 8.099 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.63     | 122.63     | 122.63     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083731   | 0.083731   | 0.083731   |   0.0 |  0.07
Output  | 0.00013532 | 0.00013532 | 0.00013532 |   0.0 |  0.00
Modify  | 0.67763    | 0.67763    | 0.67763    |   0.0 |  0.55
Other   |            | 0.08792    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8830.00 ave        8830 max        8830 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920126.0 ave      920126 max      920126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920126
Ave neighs/atom = 115.01575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.210375071515, Press = 12.9756102393755
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -57927.313   -57927.313   -58254.718   -58254.718    316.65419    316.65419    45223.014    45223.014   -1072.0489   -1072.0489 
   14000   -57937.157   -57937.157   -58255.841   -58255.841    308.21911    308.21911     45217.07     45217.07   -1245.5203   -1245.5203 
Loop time of 121.605 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.710 ns/day, 33.779 hours/ns, 8.223 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    | 120.75     | 120.75     | 120.75     |   0.0 | 99.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085347   | 0.085347   | 0.085347   |   0.0 |  0.07
Output  | 0.00014614 | 0.00014614 | 0.00014614 |   0.0 |  0.00
Modify  | 0.67854    | 0.67854    | 0.67854    |   0.0 |  0.56
Other   |            | 0.09319    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8885.00 ave        8885 max        8885 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921124.0 ave      921124 max      921124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921124
Ave neighs/atom = 115.14050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.15447694507, Press = 13.2249796236946
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -57937.157   -57937.157   -58255.841   -58255.841    308.21911    308.21911     45217.07     45217.07   -1245.5203   -1245.5203 
   15000   -57929.912   -57929.912   -58256.928   -58256.928    316.27743    316.27743    45208.657    45208.657    278.12141    278.12141 
Loop time of 121.386 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.712 ns/day, 33.718 hours/ns, 8.238 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    | 120.54     | 120.54     | 120.54     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084017   | 0.084017   | 0.084017   |   0.0 |  0.07
Output  | 0.00013421 | 0.00013421 | 0.00013421 |   0.0 |  0.00
Modify  | 0.67173    | 0.67173    | 0.67173    |   0.0 |  0.55
Other   |            | 0.08759    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8837.00 ave        8837 max        8837 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920142.0 ave      920142 max      920142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920142
Ave neighs/atom = 115.01775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.096619211908, Press = 14.8350906873508
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -57929.912   -57929.912   -58256.928   -58256.928    316.27743    316.27743    45208.657    45208.657    278.12141    278.12141 
   16000   -57933.351   -57933.351   -58253.162   -58253.162    309.30893    309.30893    45180.036    45180.036    2847.6199    2847.6199 
Loop time of 118.391 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.730 ns/day, 32.886 hours/ns, 8.447 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    | 117.56     | 117.56     | 117.56     |   0.0 | 99.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084218   | 0.084218   | 0.084218   |   0.0 |  0.07
Output  | 0.00014237 | 0.00014237 | 0.00014237 |   0.0 |  0.00
Modify  | 0.66128    | 0.66128    | 0.66128    |   0.0 |  0.56
Other   |            | 0.0878     |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8854.00 ave        8854 max        8854 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921968.0 ave      921968 max      921968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921968
Ave neighs/atom = 115.24600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.964630627119, Press = 16.8868653517372
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -57933.351   -57933.351   -58253.162   -58253.162    309.30893    309.30893    45180.036    45180.036    2847.6199    2847.6199 
   17000   -57937.528   -57937.528   -58258.677   -58258.677    310.60353    310.60353    45167.466    45167.466     4576.789     4576.789 
Loop time of 117.453 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.736 ns/day, 32.626 hours/ns, 8.514 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    | 116.62     | 116.62     | 116.62     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084263   | 0.084263   | 0.084263   |   0.0 |  0.07
Output  | 0.00012801 | 0.00012801 | 0.00012801 |   0.0 |  0.00
Modify  | 0.65858    | 0.65858    | 0.65858    |   0.0 |  0.56
Other   |            | 0.08803    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8864.00 ave        8864 max        8864 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922372.0 ave      922372 max      922372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922372
Ave neighs/atom = 115.29650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.932090003575, Press = 10.4071430340969
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -57937.528   -57937.528   -58258.677   -58258.677    310.60353    310.60353    45167.466    45167.466     4576.789     4576.789 
   18000   -57929.507   -57929.507   -58249.836   -58249.836    309.81101    309.81101    45195.879    45195.879    1392.1862    1392.1862 
Loop time of 116.845 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.739 ns/day, 32.457 hours/ns, 8.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    | 116.02     | 116.02     | 116.02     |   0.0 | 99.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083111   | 0.083111   | 0.083111   |   0.0 |  0.07
Output  | 0.00015232 | 0.00015232 | 0.00015232 |   0.0 |  0.00
Modify  | 0.65227    | 0.65227    | 0.65227    |   0.0 |  0.56
Other   |            | 0.08583    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8857.00 ave        8857 max        8857 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      923952.0 ave      923952 max      923952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 923952
Ave neighs/atom = 115.49400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.921848351835, Press = 6.03184006272387
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -57929.507   -57929.507   -58249.836   -58249.836    309.81101    309.81101    45195.879    45195.879    1392.1862    1392.1862 
   19000   -57929.022   -57929.022   -58258.397   -58258.397    318.55886    318.55886    45204.542    45204.542    805.84292    805.84292 
Loop time of 117.709 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.697 hours/ns, 8.495 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    | 116.88     | 116.88     | 116.88     |   0.0 | 99.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083424   | 0.083424   | 0.083424   |   0.0 |  0.07
Output  | 0.00012734 | 0.00012734 | 0.00012734 |   0.0 |  0.00
Modify  | 0.65557    | 0.65557    | 0.65557    |   0.0 |  0.56
Other   |            | 0.08573    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8878.00 ave        8878 max        8878 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921964.0 ave      921964 max      921964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921964
Ave neighs/atom = 115.24550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.963272247663, Press = 6.07909914497787
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -57929.022   -57929.022   -58258.397   -58258.397    318.55886    318.55886    45204.542    45204.542    805.84292    805.84292 
   20000   -57935.049   -57935.049   -58254.851   -58254.851    309.30059    309.30059     45206.68     45206.68    114.88422    114.88422 
Loop time of 115.808 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.746 ns/day, 32.169 hours/ns, 8.635 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    | 114.99     | 114.99     | 114.99     |   0.0 | 99.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082701   | 0.082701   | 0.082701   |   0.0 |  0.07
Output  | 0.00014688 | 0.00014688 | 0.00014688 |   0.0 |  0.00
Modify  | 0.64744    | 0.64744    | 0.64744    |   0.0 |  0.56
Other   |            | 0.08447    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8829.00 ave        8829 max        8829 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922230.0 ave      922230 max      922230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922230
Ave neighs/atom = 115.27875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.071236640433, Press = 5.21470758708084
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -57935.049   -57935.049   -58254.851   -58254.851    309.30059    309.30059     45206.68     45206.68    114.88422    114.88422 
   21000   -57925.558   -57925.558   -58252.513   -58252.513    316.21868    316.21868    45214.389    45214.389   -103.48806   -103.48806 
Loop time of 115.096 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.751 ns/day, 31.971 hours/ns, 8.688 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    | 114.28     | 114.28     | 114.28     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083125   | 0.083125   | 0.083125   |   0.0 |  0.07
Output  | 0.00014646 | 0.00014646 | 0.00014646 |   0.0 |  0.00
Modify  | 0.64636    | 0.64636    | 0.64636    |   0.0 |  0.56
Other   |            | 0.08689    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8861.00 ave        8861 max        8861 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921220.0 ave      921220 max      921220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921220
Ave neighs/atom = 115.15250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.138979376835, Press = 3.87866863772824
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -57925.558   -57925.558   -58252.513   -58252.513    316.21868    316.21868    45214.389    45214.389   -103.48806   -103.48806 
   22000   -57930.405   -57930.405   -58254.595   -58254.595    313.54466    313.54466     45224.68     45224.68   -1510.4566   -1510.4566 
Loop time of 118.193 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.731 ns/day, 32.831 hours/ns, 8.461 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    | 117.36     | 117.36     | 117.36     |   0.0 | 99.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083556   | 0.083556   | 0.083556   |   0.0 |  0.07
Output  | 0.0001246  | 0.0001246  | 0.0001246  |   0.0 |  0.00
Modify  | 0.65949    | 0.65949    | 0.65949    |   0.0 |  0.56
Other   |            | 0.08711    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8902.00 ave        8902 max        8902 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921346.0 ave      921346 max      921346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921346
Ave neighs/atom = 115.16825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.117567172306, Press = 2.65258949038591
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -57930.405   -57930.405   -58254.595   -58254.595    313.54466    313.54466     45224.68     45224.68   -1510.4566   -1510.4566 
   23000   -57939.237   -57939.237   -58259.815   -58259.815    310.05165    310.05165    45235.861    45235.861   -2746.2502   -2746.2502 
Loop time of 117.713 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.698 hours/ns, 8.495 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    | 116.89     | 116.89     | 116.89     |   0.0 | 99.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081952   | 0.081952   | 0.081952   |   0.0 |  0.07
Output  | 0.00015486 | 0.00015486 | 0.00015486 |   0.0 |  0.00
Modify  | 0.65312    | 0.65312    | 0.65312    |   0.0 |  0.55
Other   |            | 0.08456    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8853.00 ave        8853 max        8853 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920374.0 ave      920374 max      920374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920374
Ave neighs/atom = 115.04675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.066878453781, Press = 3.77230757628572
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -57939.237   -57939.237   -58259.815   -58259.815    310.05165    310.05165    45235.861    45235.861   -2746.2502   -2746.2502 
   24000     -57930.1     -57930.1   -58251.351   -58251.351    310.70211    310.70211    45239.524    45239.524   -3425.7792   -3425.7792 
Loop time of 121.804 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.709 ns/day, 33.834 hours/ns, 8.210 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    | 120.96     | 120.96     | 120.96     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083194   | 0.083194   | 0.083194   |   0.0 |  0.07
Output  | 0.00015649 | 0.00015649 | 0.00015649 |   0.0 |  0.00
Modify  | 0.67088    | 0.67088    | 0.67088    |   0.0 |  0.55
Other   |            | 0.0863     |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8831.00 ave        8831 max        8831 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920970.0 ave      920970 max      920970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920970
Ave neighs/atom = 115.12125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.005876882736, Press = 5.92471713622799
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000     -57930.1     -57930.1   -58251.351   -58251.351    310.70211    310.70211    45239.524    45239.524   -3425.7792   -3425.7792 
   25000   -57929.207   -57929.207   -58258.386   -58258.386    318.36895    318.36895    45222.332    45222.332   -1289.4084   -1289.4084 
Loop time of 121.137 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.713 ns/day, 33.649 hours/ns, 8.255 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    | 120.3      | 120.3      | 120.3      |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082467   | 0.082467   | 0.082467   |   0.0 |  0.07
Output  | 0.00013544 | 0.00013544 | 0.00013544 |   0.0 |  0.00
Modify  | 0.66848    | 0.66848    | 0.66848    |   0.0 |  0.55
Other   |            | 0.08628    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8872.00 ave        8872 max        8872 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      919526.0 ave      919526 max      919526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 919526
Ave neighs/atom = 114.94075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.985344763843, Press = 8.09393596689184
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -57929.207   -57929.207   -58258.386   -58258.386    318.36895    318.36895    45222.332    45222.332   -1289.4084   -1289.4084 
   26000   -57934.073   -57934.073    -58259.49    -58259.49    314.73173    314.73173    45192.273    45192.273     1803.977     1803.977 
Loop time of 120.997 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.714 ns/day, 33.610 hours/ns, 8.265 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    | 120.16     | 120.16     | 120.16     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08218    | 0.08218    | 0.08218    |   0.0 |  0.07
Output  | 0.00014859 | 0.00014859 | 0.00014859 |   0.0 |  0.00
Modify  | 0.66751    | 0.66751    | 0.66751    |   0.0 |  0.55
Other   |            | 0.08624    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8829.00 ave        8829 max        8829 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921178.0 ave      921178 max      921178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921178
Ave neighs/atom = 115.14725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.047417899458, Press = 10.3814556853898
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -57934.073   -57934.073    -58259.49    -58259.49    314.73173    314.73173    45192.273    45192.273     1803.977     1803.977 
   27000   -57924.252   -57924.252    -58251.39    -58251.39    316.39619    316.39619    45176.042    45176.042    4206.2564    4206.2564 
Loop time of 119.474 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.723 ns/day, 33.187 hours/ns, 8.370 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    | 118.65     | 118.65     | 118.65     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08073    | 0.08073    | 0.08073    |   0.0 |  0.07
Output  | 0.00014782 | 0.00014782 | 0.00014782 |   0.0 |  0.00
Modify  | 0.65554    | 0.65554    | 0.65554    |   0.0 |  0.55
Other   |            | 0.08456    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8832.00 ave        8832 max        8832 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922202.0 ave      922202 max      922202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922202
Ave neighs/atom = 115.27525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.111756385134, Press = 7.14003087681481
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -57924.252   -57924.252    -58251.39    -58251.39    316.39619    316.39619    45176.042    45176.042    4206.2564    4206.2564 
   28000   -57934.433   -57934.433   -58256.981   -58256.981    311.95627    311.95627     45188.74     45188.74      2315.46      2315.46 
Loop time of 119.772 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.721 ns/day, 33.270 hours/ns, 8.349 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    | 118.95     | 118.95     | 118.95     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081154   | 0.081154   | 0.081154   |   0.0 |  0.07
Output  | 0.00014317 | 0.00014317 | 0.00014317 |   0.0 |  0.00
Modify  | 0.65697    | 0.65697    | 0.65697    |   0.0 |  0.55
Other   |            | 0.08478    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8894.00 ave        8894 max        8894 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      923184.0 ave      923184 max      923184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 923184
Ave neighs/atom = 115.39800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.128387177012, Press = 4.33085938929508
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -57934.433   -57934.433   -58256.981   -58256.981    311.95627    311.95627     45188.74     45188.74      2315.46      2315.46 
   29000   -57939.513   -57939.513   -58262.779   -58262.779    312.65091    312.65091    45198.887    45198.887    1208.2064    1208.2064 
Loop time of 119.771 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.721 ns/day, 33.270 hours/ns, 8.349 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    | 118.95     | 118.95     | 118.95     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080313   | 0.080313   | 0.080313   |   0.0 |  0.07
Output  | 0.00014331 | 0.00014331 | 0.00014331 |   0.0 |  0.00
Modify  | 0.65454    | 0.65454    | 0.65454    |   0.0 |  0.55
Other   |            | 0.0849     |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8860.00 ave        8860 max        8860 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922430.0 ave      922430 max      922430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922430
Ave neighs/atom = 115.30375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.121857755967, Press = 3.47871928271284
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -57939.513   -57939.513   -58262.779   -58262.779    312.65091    312.65091    45198.887    45198.887    1208.2064    1208.2064 
   30000   -57931.083   -57931.083   -58252.723   -58252.723    311.07829    311.07829    45211.996    45211.996   -91.727591   -91.727591 
Loop time of 109.39 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.790 ns/day, 30.386 hours/ns, 9.142 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    | 108.62     | 108.62     | 108.62     |   0.0 | 99.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078432   | 0.078432   | 0.078432   |   0.0 |  0.07
Output  | 9.9681e-05 | 9.9681e-05 | 9.9681e-05 |   0.0 |  0.00
Modify  | 0.61025    | 0.61025    | 0.61025    |   0.0 |  0.56
Other   |            | 0.07971    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8858.00 ave        8858 max        8858 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922858.0 ave      922858 max      922858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922858
Ave neighs/atom = 115.35725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.083502742308, Press = 2.36121870545647
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -57931.083   -57931.083   -58252.723   -58252.723    311.07829    311.07829    45211.996    45211.996   -91.727591   -91.727591 
   31000    -57933.24    -57933.24   -58250.192   -58250.192    306.54468    306.54468    45244.027    45244.027   -3866.4801   -3866.4801 
Loop time of 102.276 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.845 ns/day, 28.410 hours/ns, 9.777 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    | 101.55     | 101.55     | 101.55     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07667    | 0.07667    | 0.07667    |   0.0 |  0.07
Output  | 0.00012433 | 0.00012433 | 0.00012433 |   0.0 |  0.00
Modify  | 0.57851    | 0.57851    | 0.57851    |   0.0 |  0.57
Other   |            | 0.0756     |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8865.00 ave        8865 max        8865 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921124.0 ave      921124 max      921124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921124
Ave neighs/atom = 115.14050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.027569093683, Press = 0.447058126164232
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000    -57933.24    -57933.24   -58250.192   -58250.192    306.54468    306.54468    45244.027    45244.027   -3866.4801   -3866.4801 
   32000   -57936.951   -57936.951   -58255.927   -58255.927    308.50161    308.50161    45256.369    45256.369   -5052.1065   -5052.1065 
Loop time of 110.866 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.779 ns/day, 30.796 hours/ns, 9.020 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    | 110.08     | 110.08     | 110.08     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080488   | 0.080488   | 0.080488   |   0.0 |  0.07
Output  | 0.00013789 | 0.00013789 | 0.00013789 |   0.0 |  0.00
Modify  | 0.62227    | 0.62227    | 0.62227    |   0.0 |  0.56
Other   |            | 0.08271    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8828.00 ave        8828 max        8828 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      919532.0 ave      919532 max      919532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 919532
Ave neighs/atom = 114.94150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.026042406166, Press = 3.44517782549819
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -57936.951   -57936.951   -58255.927   -58255.927    308.50161    308.50161    45256.369    45256.369   -5052.1065   -5052.1065 
   33000   -57931.643   -57931.643   -58255.303   -58255.303     313.0324     313.0324     45237.32     45237.32   -2828.4656   -2828.4656 
Loop time of 105.871 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.816 ns/day, 29.409 hours/ns, 9.445 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    | 105.12     | 105.12     | 105.12     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077522   | 0.077522   | 0.077522   |   0.0 |  0.07
Output  | 0.00013472 | 0.00013472 | 0.00013472 |   0.0 |  0.00
Modify  | 0.59694    | 0.59694    | 0.59694    |   0.0 |  0.56
Other   |            | 0.07808    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8800.00 ave        8800 max        8800 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      919042.0 ave      919042 max      919042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 919042
Ave neighs/atom = 114.88025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.07024213352, Press = 4.8303528170469
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -57931.643   -57931.643   -58255.303   -58255.303     313.0324     313.0324     45237.32     45237.32   -2828.4656   -2828.4656 
   34000   -57925.802   -57925.802    -58251.14    -58251.14    314.65475    314.65475    45219.647    45219.647   -1043.8519   -1043.8519 
Loop time of 102.007 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.847 ns/day, 28.335 hours/ns, 9.803 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    | 101.28     | 101.28     | 101.28     |   0.0 | 99.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077025   | 0.077025   | 0.077025   |   0.0 |  0.08
Output  | 0.00012933 | 0.00012933 | 0.00012933 |   0.0 |  0.00
Modify  | 0.57828    | 0.57828    | 0.57828    |   0.0 |  0.57
Other   |            | 0.07577    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8926.00 ave        8926 max        8926 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920024.0 ave      920024 max      920024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920024
Ave neighs/atom = 115.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.099032347695, Press = 4.80200424970474
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -57925.802   -57925.802    -58251.14    -58251.14    314.65475    314.65475    45219.647    45219.647   -1043.8519   -1043.8519 
   35000   -57936.173   -57936.173   -58259.188   -58259.188    312.40823    312.40823    45199.245    45199.245    1061.2736    1061.2736 
Loop time of 102.168 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.846 ns/day, 28.380 hours/ns, 9.788 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    | 101.44     | 101.44     | 101.44     |   0.0 | 99.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07657    | 0.07657    | 0.07657    |   0.0 |  0.07
Output  | 0.0001387  | 0.0001387  | 0.0001387  |   0.0 |  0.00
Modify  | 0.57903    | 0.57903    | 0.57903    |   0.0 |  0.57
Other   |            | 0.07555    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8835.00 ave        8835 max        8835 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920096.0 ave      920096 max      920096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920096
Ave neighs/atom = 115.01200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.135188743865, Press = 4.53451106556869
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -57936.173   -57936.173   -58259.188   -58259.188    312.40823    312.40823    45199.245    45199.245    1061.2736    1061.2736 
   36000   -57938.849   -57938.849   -58261.326   -58261.326    311.88763    311.88763    45183.071    45183.071    2876.7671    2876.7671 
Loop time of 102.142 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.846 ns/day, 28.373 hours/ns, 9.790 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    | 101.41     | 101.41     | 101.41     |   0.0 | 99.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076512   | 0.076512   | 0.076512   |   0.0 |  0.07
Output  | 0.00012973 | 0.00012973 | 0.00012973 |   0.0 |  0.00
Modify  | 0.57811    | 0.57811    | 0.57811    |   0.0 |  0.57
Other   |            | 0.07575    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8852.00 ave        8852 max        8852 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922628.0 ave      922628 max      922628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922628
Ave neighs/atom = 115.32850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.139500002915, Press = 3.39491808380449
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -57938.849   -57938.849   -58261.326   -58261.326    311.88763    311.88763    45183.071    45183.071    2876.7671    2876.7671 
   37000   -57930.886   -57930.886    -58254.09    -58254.09    312.59014    312.59014    45173.631    45173.631    3890.0113    3890.0113 
Loop time of 102.203 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.845 ns/day, 28.390 hours/ns, 9.784 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    | 101.47     | 101.47     | 101.47     |   0.0 | 99.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076859   | 0.076859   | 0.076859   |   0.0 |  0.08
Output  | 0.00014188 | 0.00014188 | 0.00014188 |   0.0 |  0.00
Modify  | 0.57894    | 0.57894    | 0.57894    |   0.0 |  0.57
Other   |            | 0.07594    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8851.00 ave        8851 max        8851 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      923006.0 ave      923006 max      923006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 923006
Ave neighs/atom = 115.37575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.099037170693, Press = 0.4612621866023
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -57930.886   -57930.886    -58254.09    -58254.09    312.59014    312.59014    45173.631    45173.631    3890.0113    3890.0113 
   38000   -57940.218   -57940.218   -58260.555   -58260.555    309.81738    309.81738    45208.031    45208.031   -134.95525   -134.95525 
Loop time of 102.402 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.844 ns/day, 28.445 hours/ns, 9.765 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    | 101.67     | 101.67     | 101.67     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076531   | 0.076531   | 0.076531   |   0.0 |  0.07
Output  | 9.5325e-05 | 9.5325e-05 | 9.5325e-05 |   0.0 |  0.00
Modify  | 0.57856    | 0.57856    | 0.57856    |   0.0 |  0.56
Other   |            | 0.07573    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8855.00 ave        8855 max        8855 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922796.0 ave      922796 max      922796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922796
Ave neighs/atom = 115.34950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.074146761964, Press = 0.466690563928892
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -57940.218   -57940.218   -58260.555   -58260.555    309.81738    309.81738    45208.031    45208.031   -134.95525   -134.95525 
   39000   -57934.567   -57934.567   -58256.205   -58256.205    311.07677    311.07677      45222.1      45222.1   -1385.8131   -1385.8131 
Loop time of 102.188 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.846 ns/day, 28.386 hours/ns, 9.786 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    | 101.46     | 101.46     | 101.46     |   0.0 | 99.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076609   | 0.076609   | 0.076609   |   0.0 |  0.07
Output  | 0.00012946 | 0.00012946 | 0.00012946 |   0.0 |  0.00
Modify  | 0.57898    | 0.57898    | 0.57898    |   0.0 |  0.57
Other   |            | 0.0757     |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8847.00 ave        8847 max        8847 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921462.0 ave      921462 max      921462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921462
Ave neighs/atom = 115.18275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.064303393654, Press = 2.04730354206617
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -57934.567   -57934.567   -58256.205   -58256.205    311.07677    311.07677      45222.1      45222.1   -1385.8131   -1385.8131 
   40000   -57932.149   -57932.149   -58253.424   -58253.424    310.72504    310.72504    45227.533    45227.533   -1754.6281   -1754.6281 
Loop time of 102.288 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.845 ns/day, 28.413 hours/ns, 9.776 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    | 101.56     | 101.56     | 101.56     |   0.0 | 99.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076685   | 0.076685   | 0.076685   |   0.0 |  0.07
Output  | 0.00012655 | 0.00012655 | 0.00012655 |   0.0 |  0.00
Modify  | 0.57902    | 0.57902    | 0.57902    |   0.0 |  0.57
Other   |            | 0.07575    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8829.00 ave        8829 max        8829 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920986.0 ave      920986 max      920986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920986
Ave neighs/atom = 115.12325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.06754609008, Press = 2.76144311459204
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -57932.149   -57932.149   -58253.424   -58253.424    310.72504    310.72504    45227.533    45227.533   -1754.6281   -1754.6281 
   41000   -57937.446   -57937.446   -58259.475   -58259.475    311.45504    311.45504    45229.305    45229.305   -2244.1838   -2244.1838 
Loop time of 102.202 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.845 ns/day, 28.390 hours/ns, 9.785 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    | 101.47     | 101.47     | 101.47     |   0.0 | 99.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07647    | 0.07647    | 0.07647    |   0.0 |  0.07
Output  | 0.00012949 | 0.00012949 | 0.00012949 |   0.0 |  0.00
Modify  | 0.57887    | 0.57887    | 0.57887    |   0.0 |  0.57
Other   |            | 0.07587    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8872.00 ave        8872 max        8872 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920778.0 ave      920778 max      920778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920778
Ave neighs/atom = 115.09725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.075814026647, Press = 3.72464357925991
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -57937.446   -57937.446   -58259.475   -58259.475    311.45504    311.45504    45229.305    45229.305   -2244.1838   -2244.1838 
   42000   -57929.204   -57929.204   -58254.175   -58254.175    314.30029    314.30029    45227.896    45227.896   -1766.9993   -1766.9993 
Loop time of 102.294 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.845 ns/day, 28.415 hours/ns, 9.776 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    | 101.56     | 101.56     | 101.56     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076848   | 0.076848   | 0.076848   |   0.0 |  0.08
Output  | 0.00012834 | 0.00012834 | 0.00012834 |   0.0 |  0.00
Modify  | 0.57863    | 0.57863    | 0.57863    |   0.0 |  0.57
Other   |            | 0.07573    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8876.00 ave        8876 max        8876 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920714.0 ave      920714 max      920714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920714
Ave neighs/atom = 115.08925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.073362662859, Press = 7.36176650351751
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -57929.204   -57929.204   -58254.175   -58254.175    314.30029    314.30029    45227.896    45227.896   -1766.9993   -1766.9993 
   43000   -57938.175   -57938.175   -58261.599   -58261.599     312.8032     312.8032    45189.766    45189.766     1853.635     1853.635 
Loop time of 102.245 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.845 ns/day, 28.402 hours/ns, 9.780 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    | 101.51     | 101.51     | 101.51     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076158   | 0.076158   | 0.076158   |   0.0 |  0.07
Output  | 0.00014295 | 0.00014295 | 0.00014295 |   0.0 |  0.00
Modify  | 0.57877    | 0.57877    | 0.57877    |   0.0 |  0.57
Other   |            | 0.07562    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8829.00 ave        8829 max        8829 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920540.0 ave      920540 max      920540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920540
Ave neighs/atom = 115.06750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.066800486966, Press = 5.4827010025551
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -57938.175   -57938.175   -58261.599   -58261.599     312.8032     312.8032    45189.766    45189.766     1853.635     1853.635 
   44000   -57929.289   -57929.289   -58253.585   -58253.585    313.64708    313.64708    45185.938    45185.938    2866.2617    2866.2617 
Loop time of 104.109 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.830 ns/day, 28.919 hours/ns, 9.605 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    | 103.37     | 103.37     | 103.37     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077403   | 0.077403   | 0.077403   |   0.0 |  0.07
Output  | 0.00014567 | 0.00014567 | 0.00014567 |   0.0 |  0.00
Modify  | 0.5874     | 0.5874     | 0.5874     |   0.0 |  0.56
Other   |            | 0.07728    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8876.00 ave        8876 max        8876 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922654.0 ave      922654 max      922654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922654
Ave neighs/atom = 115.33175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.035639830088, Press = 3.74202553574663
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -57929.289   -57929.289   -58253.585   -58253.585    313.64708    313.64708    45185.938    45185.938    2866.2617    2866.2617 
   45000   -57942.587   -57942.587   -58263.478   -58263.478    310.35429    310.35429    45183.231    45183.231    2428.6953    2428.6953 
Loop time of 115.36 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.749 ns/day, 32.044 hours/ns, 8.669 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    | 114.55     | 114.55     | 114.55     |   0.0 | 99.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082488   | 0.082488   | 0.082488   |   0.0 |  0.07
Output  | 0.00012202 | 0.00012202 | 0.00012202 |   0.0 |  0.00
Modify  | 0.64351    | 0.64351    | 0.64351    |   0.0 |  0.56
Other   |            | 0.08564    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8919.00 ave        8919 max        8919 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922570.0 ave      922570 max      922570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922570
Ave neighs/atom = 115.32125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.013865977344, Press = 2.4343983864054
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -57942.587   -57942.587   -58263.478   -58263.478    310.35429    310.35429    45183.231    45183.231    2428.6953    2428.6953 
   46000   -57930.547   -57930.547   -58255.144   -58255.144    313.93771    313.93771    45197.022    45197.022    1396.4388    1396.4388 
Loop time of 115.228 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.750 ns/day, 32.008 hours/ns, 8.678 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    | 114.42     | 114.42     | 114.42     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082412   | 0.082412   | 0.082412   |   0.0 |  0.07
Output  | 0.00011005 | 0.00011005 | 0.00011005 |   0.0 |  0.00
Modify  | 0.64384    | 0.64384    | 0.64384    |   0.0 |  0.56
Other   |            | 0.08606    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8848.00 ave        8848 max        8848 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      923270.0 ave      923270 max      923270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 923270
Ave neighs/atom = 115.40875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.001586167859, Press = 1.6418679267758
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -57930.547   -57930.547   -58255.144   -58255.144    313.93771    313.93771    45197.022    45197.022    1396.4388    1396.4388 
   47000    -57928.75    -57928.75   -58252.863   -58252.863    313.47035    313.47035    45210.778    45210.778    21.239565    21.239565 
Loop time of 115.266 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.750 ns/day, 32.018 hours/ns, 8.676 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    | 114.46     | 114.46     | 114.46     |   0.0 | 99.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08211    | 0.08211    | 0.08211    |   0.0 |  0.07
Output  | 0.000134   | 0.000134   | 0.000134   |   0.0 |  0.00
Modify  | 0.64125    | 0.64125    | 0.64125    |   0.0 |  0.56
Other   |            | 0.08557    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8855.00 ave        8855 max        8855 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922096.0 ave      922096 max      922096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922096
Ave neighs/atom = 115.26200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.987606073645, Press = 1.37262500048261
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000    -57928.75    -57928.75   -58252.863   -58252.863    313.47035    313.47035    45210.778    45210.778    21.239565    21.239565 
   48000   -57932.907   -57932.907   -58258.655   -58258.655    315.05145    315.05145    45220.449    45220.449   -1003.8959   -1003.8959 
Loop time of 115.187 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.750 ns/day, 31.996 hours/ns, 8.682 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    | 114.38     | 114.38     | 114.38     |   0.0 | 99.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082603   | 0.082603   | 0.082603   |   0.0 |  0.07
Output  | 0.00014393 | 0.00014393 | 0.00014393 |   0.0 |  0.00
Modify  | 0.64271    | 0.64271    | 0.64271    |   0.0 |  0.56
Other   |            | 0.08587    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8886.00 ave        8886 max        8886 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921220.0 ave      921220 max      921220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921220
Ave neighs/atom = 115.15250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.012822568458, Press = 1.48158279789144
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -57932.907   -57932.907   -58258.655   -58258.655    315.05145    315.05145    45220.449    45220.449   -1003.8959   -1003.8959 
   49000   -57922.047   -57922.047    -58251.04    -58251.04    318.19052    318.19052     45250.51     45250.51   -4008.8757   -4008.8757 
Loop time of 115.303 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.749 ns/day, 32.029 hours/ns, 8.673 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    | 114.49     | 114.49     | 114.49     |   0.0 | 99.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081973   | 0.081973   | 0.081973   |   0.0 |  0.07
Output  | 0.00013185 | 0.00013185 | 0.00013185 |   0.0 |  0.00
Modify  | 0.642      | 0.642      | 0.642      |   0.0 |  0.56
Other   |            | 0.08521    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8813.00 ave        8813 max        8813 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921270.0 ave      921270 max      921270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921270
Ave neighs/atom = 115.15875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.037601642345, Press = 1.73398092056807
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -57922.047   -57922.047    -58251.04    -58251.04    318.19052    318.19052     45250.51     45250.51   -4008.8757   -4008.8757 
   50000   -57936.783   -57936.783   -58256.281   -58256.281    309.00602    309.00602    45256.713    45256.713   -5117.9355   -5117.9355 
Loop time of 114.97 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.752 ns/day, 31.936 hours/ns, 8.698 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    | 114.16     | 114.16     | 114.16     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082402   | 0.082402   | 0.082402   |   0.0 |  0.07
Output  | 0.00013904 | 0.00013904 | 0.00013904 |   0.0 |  0.00
Modify  | 0.64256    | 0.64256    | 0.64256    |   0.0 |  0.56
Other   |            | 0.08561    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8871.00 ave        8871 max        8871 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      918822.0 ave      918822 max      918822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918822
Ave neighs/atom = 114.85275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.05832434434, Press = 3.18712753308753
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -57936.783   -57936.783   -58256.281   -58256.281    309.00602    309.00602    45256.713    45256.713   -5117.9355   -5117.9355 
   51000   -57936.576   -57936.576   -58256.276   -58256.276    309.20276    309.20276    45221.374    45221.374    -1321.826    -1321.826 
Loop time of 109.458 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.789 ns/day, 30.405 hours/ns, 9.136 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    | 108.68     | 108.68     | 108.68     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079893   | 0.079893   | 0.079893   |   0.0 |  0.07
Output  | 0.00014986 | 0.00014986 | 0.00014986 |   0.0 |  0.00
Modify  | 0.61543    | 0.61543    | 0.61543    |   0.0 |  0.56
Other   |            | 0.08134    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8847.00 ave        8847 max        8847 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      919158.0 ave      919158 max      919158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 919158
Ave neighs/atom = 114.89475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.059473370722, Press = 3.39490760607596
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -57936.576   -57936.576   -58256.276   -58256.276    309.20276    309.20276    45221.374    45221.374    -1321.826    -1321.826 
   52000   -57930.951   -57930.951   -58255.017   -58255.017    313.42458    313.42458    45209.716    45209.716    44.801135    44.801135 
Loop time of 102.03 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.847 ns/day, 28.342 hours/ns, 9.801 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    | 101.3      | 101.3      | 101.3      |   0.0 | 99.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077029   | 0.077029   | 0.077029   |   0.0 |  0.08
Output  | 0.00013387 | 0.00013387 | 0.00013387 |   0.0 |  0.00
Modify  | 0.57804    | 0.57804    | 0.57804    |   0.0 |  0.57
Other   |            | 0.07556    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8841.00 ave        8841 max        8841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921048.0 ave      921048 max      921048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921048
Ave neighs/atom = 115.13100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.031987659371, Press = 3.04281422275169
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -57930.951   -57930.951   -58255.017   -58255.017    313.42458    313.42458    45209.716    45209.716    44.801135    44.801135 
   53000   -57939.065   -57939.065   -58256.945   -58256.945    307.44234    307.44234    45199.704    45199.704    1285.0996    1285.0996 
Loop time of 106.315 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.813 ns/day, 29.532 hours/ns, 9.406 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    | 105.56     | 105.56     | 105.56     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078702   | 0.078702   | 0.078702   |   0.0 |  0.07
Output  | 0.00014721 | 0.00014721 | 0.00014721 |   0.0 |  0.00
Modify  | 0.59848    | 0.59848    | 0.59848    |   0.0 |  0.56
Other   |            | 0.07888    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8852.00 ave        8852 max        8852 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921520.0 ave      921520 max      921520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921520
Ave neighs/atom = 115.19000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.012461348691, Press = 2.4368437436217
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -57939.065   -57939.065   -58256.945   -58256.945    307.44234    307.44234    45199.704    45199.704    1285.0996    1285.0996 
   54000   -57928.319   -57928.319   -58250.755   -58250.755    311.84878    311.84878    45196.381    45196.381     2003.388     2003.388 
Loop time of 114.876 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.752 ns/day, 31.910 hours/ns, 8.705 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    | 114.07     | 114.07     | 114.07     |   0.0 | 99.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081473   | 0.081473   | 0.081473   |   0.0 |  0.07
Output  | 0.00027914 | 0.00027914 | 0.00027914 |   0.0 |  0.00
Modify  | 0.64144    | 0.64144    | 0.64144    |   0.0 |  0.56
Other   |            | 0.08509    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8881.00 ave        8881 max        8881 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922302.0 ave      922302 max      922302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922302
Ave neighs/atom = 115.28775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.000203225938, Press = 1.71839044978691
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -57928.319   -57928.319   -58250.755   -58250.755    311.84878    311.84878    45196.381    45196.381     2003.388     2003.388 
   55000    -57929.76    -57929.76    -58248.55    -58248.55    308.32159    308.32159    45201.819    45201.819    992.49047    992.49047 
Loop time of 110.992 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.778 ns/day, 30.831 hours/ns, 9.010 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    | 110.2      | 110.2      | 110.2      |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079164   | 0.079164   | 0.079164   |   0.0 |  0.07
Output  | 0.00013844 | 0.00013844 | 0.00013844 |   0.0 |  0.00
Modify  | 0.62462    | 0.62462    | 0.62462    |   0.0 |  0.56
Other   |            | 0.08354    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8820.00 ave        8820 max        8820 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922376.0 ave      922376 max      922376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922376
Ave neighs/atom = 115.29700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.992002595223, Press = 0.61997510255543
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000    -57929.76    -57929.76    -58248.55    -58248.55    308.32159    308.32159    45201.819    45201.819    992.49047    992.49047 
   56000   -57933.038   -57933.038   -58258.587   -58258.587    314.85888    314.85888    45221.726    45221.726   -1074.8244   -1074.8244 
Loop time of 109.045 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.792 ns/day, 30.290 hours/ns, 9.171 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    | 108.27     | 108.27     | 108.27     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078744   | 0.078744   | 0.078744   |   0.0 |  0.07
Output  | 0.00024719 | 0.00024719 | 0.00024719 |   0.0 |  0.00
Modify  | 0.61216    | 0.61216    | 0.61216    |   0.0 |  0.56
Other   |            | 0.08093    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8876.00 ave        8876 max        8876 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921342.0 ave      921342 max      921342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921342
Ave neighs/atom = 115.16775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.023058376044, Press = 0.479688461184078
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -57933.038   -57933.038   -58258.587   -58258.587    314.85888    314.85888    45221.726    45221.726   -1074.8244   -1074.8244 
   57000   -57926.193   -57926.193   -58254.633   -58254.633    317.65509    317.65509    45238.467    45238.467   -2957.9029   -2957.9029 
Loop time of 108.031 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.800 ns/day, 30.009 hours/ns, 9.257 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    | 107.25     | 107.25     | 107.25     |   0.0 | 99.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079448   | 0.079448   | 0.079448   |   0.0 |  0.07
Output  | 0.00014306 | 0.00014306 | 0.00014306 |   0.0 |  0.00
Modify  | 0.61291    | 0.61291    | 0.61291    |   0.0 |  0.57
Other   |            | 0.08336    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8898.00 ave        8898 max        8898 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921242.0 ave      921242 max      921242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921242
Ave neighs/atom = 115.15525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.037313006036, Press = 1.26502552234566
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -57926.193   -57926.193   -58254.633   -58254.633    317.65509    317.65509    45238.467    45238.467   -2957.9029   -2957.9029 
   58000   -57931.809   -57931.809   -58257.483   -58257.483    314.97978    314.97978    45235.578    45235.578   -2560.1504   -2560.1504 
Loop time of 108.524 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.796 ns/day, 30.146 hours/ns, 9.215 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    | 107.75     | 107.75     | 107.75     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078695   | 0.078695   | 0.078695   |   0.0 |  0.07
Output  | 0.00013753 | 0.00013753 | 0.00013753 |   0.0 |  0.00
Modify  | 0.6133     | 0.6133     | 0.6133     |   0.0 |  0.57
Other   |            | 0.08193    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8846.00 ave        8846 max        8846 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      919882.0 ave      919882 max      919882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 919882
Ave neighs/atom = 114.98525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.038334284409, Press = 2.18190489470427
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -57931.809   -57931.809   -58257.483   -58257.483    314.97978    314.97978    45235.578    45235.578   -2560.1504   -2560.1504 
   59000   -57935.976   -57935.976   -58258.005   -58258.005    311.45429    311.45429    45224.588    45224.588   -1531.2539   -1531.2539 
Loop time of 101.215 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.854 ns/day, 28.115 hours/ns, 9.880 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    | 100.49     | 100.49     | 100.49     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075596   | 0.075596   | 0.075596   |   0.0 |  0.07
Output  | 0.00013095 | 0.00013095 | 0.00013095 |   0.0 |  0.00
Modify  | 0.57233    | 0.57233    | 0.57233    |   0.0 |  0.57
Other   |            | 0.07444    |            |       |  0.07

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8848.00 ave        8848 max        8848 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920238.0 ave      920238 max      920238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920238
Ave neighs/atom = 115.02975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.044020727809, Press = 2.89760040211107
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -57935.976   -57935.976   -58258.005   -58258.005    311.45429    311.45429    45224.588    45224.588   -1531.2539   -1531.2539 
   60000   -57922.562   -57922.562   -58252.222   -58252.222    318.83482    318.83482    45210.424    45210.424    350.41442    350.41442 
Loop time of 104.98 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.823 ns/day, 29.161 hours/ns, 9.526 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    | 104.22     | 104.22     | 104.22     |   0.0 | 99.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078436   | 0.078436   | 0.078436   |   0.0 |  0.07
Output  | 0.00025079 | 0.00025079 | 0.00025079 |   0.0 |  0.00
Modify  | 0.59917    | 0.59917    | 0.59917    |   0.0 |  0.57
Other   |            | 0.08286    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8861.00 ave        8861 max        8861 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920656.0 ave      920656 max      920656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920656
Ave neighs/atom = 115.08200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.067831579799, Press = 3.61976284690747
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -57922.562   -57922.562   -58252.222   -58252.222    318.83482    318.83482    45210.424    45210.424    350.41442    350.41442 
   61000   -57933.373   -57933.373   -58256.824   -58256.824    312.83022    312.83022    45183.317    45183.317    2706.3253    2706.3253 
Loop time of 109.474 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.789 ns/day, 30.409 hours/ns, 9.135 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    | 108.67     | 108.67     | 108.67     |   0.0 | 99.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08227    | 0.08227    | 0.08227    |   0.0 |  0.08
Output  | 0.00015239 | 0.00015239 | 0.00015239 |   0.0 |  0.00
Modify  | 0.63204    | 0.63204    | 0.63204    |   0.0 |  0.58
Other   |            | 0.09373    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8857.00 ave        8857 max        8857 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921592.0 ave      921592 max      921592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921592
Ave neighs/atom = 115.19900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.081198215202, Press = 3.48088928009106
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -57933.373   -57933.373   -58256.824   -58256.824    312.83022    312.83022    45183.317    45183.317    2706.3253    2706.3253 
   62000   -57925.703   -57925.703   -58251.252   -58251.252    314.85909    314.85909    45189.636    45189.636    2307.0527    2307.0527 
Loop time of 105.317 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.820 ns/day, 29.255 hours/ns, 9.495 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    | 104.56     | 104.56     | 104.56     |   0.0 | 99.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079471   | 0.079471   | 0.079471   |   0.0 |  0.08
Output  | 0.00027305 | 0.00027305 | 0.00027305 |   0.0 |  0.00
Modify  | 0.59826    | 0.59826    | 0.59826    |   0.0 |  0.57
Other   |            | 0.0818     |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8854.00 ave        8854 max        8854 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922332.0 ave      922332 max      922332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922332
Ave neighs/atom = 115.29150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.108016747898, Press = 2.23718942849735
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -57925.703   -57925.703   -58251.252   -58251.252    314.85909    314.85909    45189.636    45189.636    2307.0527    2307.0527 
   63000   -57932.388   -57932.388   -58256.756   -58256.756    313.71647    313.71647    45200.596    45200.596    1083.7644    1083.7644 
Loop time of 106.836 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.809 ns/day, 29.677 hours/ns, 9.360 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    | 106.06     | 106.06     | 106.06     |   0.0 | 99.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080399   | 0.080399   | 0.080399   |   0.0 |  0.08
Output  | 0.00015567 | 0.00015567 | 0.00015567 |   0.0 |  0.00
Modify  | 0.61139    | 0.61139    | 0.61139    |   0.0 |  0.57
Other   |            | 0.08591    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8836.00 ave        8836 max        8836 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922350.0 ave      922350 max      922350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922350
Ave neighs/atom = 115.29375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.113106858086, Press = 1.69981146191256
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -57932.388   -57932.388   -58256.756   -58256.756    313.71647    313.71647    45200.596    45200.596    1083.7644    1083.7644 
   64000   -57932.293   -57932.293   -58255.701   -58255.701    312.78807    312.78807     45207.96     45207.96    487.63273    487.63273 
Loop time of 106.992 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.808 ns/day, 29.720 hours/ns, 9.347 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    | 106.21     | 106.21     | 106.21     |   0.0 | 99.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080901   | 0.080901   | 0.080901   |   0.0 |  0.08
Output  | 0.00013099 | 0.00013099 | 0.00013099 |   0.0 |  0.00
Modify  | 0.6135     | 0.6135     | 0.6135     |   0.0 |  0.57
Other   |            | 0.08685    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8859.00 ave        8859 max        8859 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921932.0 ave      921932 max      921932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921932
Ave neighs/atom = 115.24150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.127889147092, Press = 1.62678088325144
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -57932.293   -57932.293   -58255.701   -58255.701    312.78807    312.78807     45207.96     45207.96    487.63273    487.63273 
   65000   -57926.368   -57926.368   -58251.202   -58251.202    314.16712    314.16712    45208.539    45208.539    491.38809    491.38809 
Loop time of 106.748 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.809 ns/day, 29.652 hours/ns, 9.368 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    | 105.96     | 105.96     | 105.96     |   0.0 | 99.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081223   | 0.081223   | 0.081223   |   0.0 |  0.08
Output  | 0.00028462 | 0.00028462 | 0.00028462 |   0.0 |  0.00
Modify  | 0.61351    | 0.61351    | 0.61351    |   0.0 |  0.57
Other   |            | 0.09028    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8874.00 ave        8874 max        8874 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921724.0 ave      921724 max      921724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921724
Ave neighs/atom = 115.21550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.131774927626, Press = 1.63557131894494
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -57926.368   -57926.368   -58251.202   -58251.202    314.16712    314.16712    45208.539    45208.539    491.38809    491.38809 
   66000   -57935.057   -57935.057   -58260.054   -58260.054    314.32496    314.32496    45199.968    45199.968    1030.2871    1030.2871 
Loop time of 108.748 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.795 ns/day, 30.208 hours/ns, 9.196 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    | 107.94     | 107.94     | 107.94     |   0.0 | 99.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084551   | 0.084551   | 0.084551   |   0.0 |  0.08
Output  | 0.00013651 | 0.00013651 | 0.00013651 |   0.0 |  0.00
Modify  | 0.62993    | 0.62993    | 0.62993    |   0.0 |  0.58
Other   |            | 0.09406    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8872.00 ave        8872 max        8872 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921292.0 ave      921292 max      921292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921292
Ave neighs/atom = 115.16150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.144598885435, Press = 1.15116416652364
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -57935.057   -57935.057   -58260.054   -58260.054    314.32496    314.32496    45199.968    45199.968    1030.2871    1030.2871 
   67000   -57930.897   -57930.897   -58252.747   -58252.747    311.28131    311.28131    45218.501    45218.501    -911.2237    -911.2237 
Loop time of 109.869 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.786 ns/day, 30.519 hours/ns, 9.102 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    | 109.09     | 109.09     | 109.09     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082147   | 0.082147   | 0.082147   |   0.0 |  0.07
Output  | 0.00013245 | 0.00013245 | 0.00013245 |   0.0 |  0.00
Modify  | 0.61766    | 0.61766    | 0.61766    |   0.0 |  0.56
Other   |            | 0.08369    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8830.00 ave        8830 max        8830 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922670.0 ave      922670 max      922670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922670
Ave neighs/atom = 115.33375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.152687653962, Press = 0.409434345655951
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -57930.897   -57930.897   -58252.747   -58252.747    311.28131    311.28131    45218.501    45218.501    -911.2237    -911.2237 
   68000   -57931.264   -57931.264     -58254.8     -58254.8    312.91155    312.91155    45251.081    45251.081   -4330.9294   -4330.9294 
Loop time of 110.485 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.782 ns/day, 30.690 hours/ns, 9.051 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    | 109.66     | 109.66     | 109.66     |   0.0 | 99.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085725   | 0.085725   | 0.085725   |   0.0 |  0.08
Output  | 0.00013279 | 0.00013279 | 0.00013279 |   0.0 |  0.00
Modify  | 0.63748    | 0.63748    | 0.63748    |   0.0 |  0.58
Other   |            | 0.09684    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8857.00 ave        8857 max        8857 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921358.0 ave      921358 max      921358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921358
Ave neighs/atom = 115.16975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.153780097066, Press = 0.634852629160096
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -57931.264   -57931.264     -58254.8     -58254.8    312.91155    312.91155    45251.081    45251.081   -4330.9294   -4330.9294 
   69000   -57934.537   -57934.537   -58256.193   -58256.193    311.09404    311.09404    45241.814    45241.814   -3404.8794   -3404.8794 
Loop time of 108.744 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.795 ns/day, 30.207 hours/ns, 9.196 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    | 107.94     | 107.94     | 107.94     |   0.0 | 99.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083452   | 0.083452   | 0.083452   |   0.0 |  0.08
Output  | 0.00014913 | 0.00014913 | 0.00014913 |   0.0 |  0.00
Modify  | 0.6279     | 0.6279     | 0.6279     |   0.0 |  0.58
Other   |            | 0.09441    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8813.00 ave        8813 max        8813 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      919584.0 ave      919584 max      919584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 919584
Ave neighs/atom = 114.94800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.162515397722, Press = 1.82633877812349
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -57934.537   -57934.537   -58256.193   -58256.193    311.09404    311.09404    45241.814    45241.814   -3404.8794   -3404.8794 
   70000   -57925.821   -57925.821   -58250.668   -58250.668    314.17952    314.17952    45223.475    45223.475   -944.55137   -944.55137 
Loop time of 110.298 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.783 ns/day, 30.638 hours/ns, 9.066 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    | 109.47     | 109.47     | 109.47     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086341   | 0.086341   | 0.086341   |   0.0 |  0.08
Output  | 0.00015413 | 0.00015413 | 0.00015413 |   0.0 |  0.00
Modify  | 0.64252    | 0.64252    | 0.64252    |   0.0 |  0.58
Other   |            | 0.09977    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8860.00 ave        8860 max        8860 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      919928.0 ave      919928 max      919928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 919928
Ave neighs/atom = 114.99100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.165448981861, Press = 2.21059241724058
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -57925.821   -57925.821   -58250.668   -58250.668    314.17952    314.17952    45223.475    45223.475   -944.55137   -944.55137 
   71000   -57935.921   -57935.921   -58262.843   -58262.843    316.18676    316.18676    45206.104    45206.104    516.27582    516.27582 
Loop time of 109.356 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.790 ns/day, 30.377 hours/ns, 9.144 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    | 108.54     | 108.54     | 108.54     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084913   | 0.084913   | 0.084913   |   0.0 |  0.08
Output  | 0.00014022 | 0.00014022 | 0.00014022 |   0.0 |  0.00
Modify  | 0.63484    | 0.63484    | 0.63484    |   0.0 |  0.58
Other   |            | 0.09729    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8897.00 ave        8897 max        8897 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920550.0 ave      920550 max      920550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920550
Ave neighs/atom = 115.06875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.185301984132, Press = 2.08537943753549
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -57935.921   -57935.921   -58262.843   -58262.843    316.18676    316.18676    45206.104    45206.104    516.27582    516.27582 
   72000   -57929.617   -57929.617   -58254.452   -58254.452    314.16818    314.16818    45197.892    45197.892    1752.7473    1752.7473 
Loop time of 111.436 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.775 ns/day, 30.954 hours/ns, 8.974 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    | 110.6      | 110.6      | 110.6      |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086305   | 0.086305   | 0.086305   |   0.0 |  0.08
Output  | 0.00014924 | 0.00014924 | 0.00014924 |   0.0 |  0.00
Modify  | 0.65017    | 0.65017    | 0.65017    |   0.0 |  0.58
Other   |            | 0.1015     |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8802.00 ave        8802 max        8802 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922198.0 ave      922198 max      922198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922198
Ave neighs/atom = 115.27475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.195148029098, Press = 1.75121223528416
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -57929.617   -57929.617   -58254.452   -58254.452    314.16818    314.16818    45197.892    45197.892    1752.7473    1752.7473 
   73000   -57934.085   -57934.085   -58255.463   -58255.463     310.8251     310.8251     45197.91     45197.91    1275.1917    1275.1917 
Loop time of 111.988 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.772 ns/day, 31.108 hours/ns, 8.930 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    | 111.14     | 111.14     | 111.14     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.087161   | 0.087161   | 0.087161   |   0.0 |  0.08
Output  | 0.0001392  | 0.0001392  | 0.0001392  |   0.0 |  0.00
Modify  | 0.65385    | 0.65385    | 0.65385    |   0.0 |  0.58
Other   |            | 0.1024     |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8836.00 ave        8836 max        8836 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922444.0 ave      922444 max      922444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922444
Ave neighs/atom = 115.30550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.192264265344, Press = 1.15819761245006
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -57934.085   -57934.085   -58255.463   -58255.463     310.8251     310.8251     45197.91     45197.91    1275.1917    1275.1917 
   74000   -57934.944   -57934.944   -58251.955   -58251.955    306.60108    306.60108    45211.706    45211.706   -290.36165   -290.36165 
Loop time of 110.207 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.784 ns/day, 30.613 hours/ns, 9.074 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    | 109.38     | 109.38     | 109.38     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086379   | 0.086379   | 0.086379   |   0.0 |  0.08
Output  | 0.00014897 | 0.00014897 | 0.00014897 |   0.0 |  0.00
Modify  | 0.6412     | 0.6412     | 0.6412     |   0.0 |  0.58
Other   |            | 0.09852    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8885.00 ave        8885 max        8885 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922254.0 ave      922254 max      922254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922254
Ave neighs/atom = 115.28175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.202563190083, Press = 0.621479753743909
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -57934.944   -57934.944   -58251.955   -58251.955    306.60108    306.60108    45211.706    45211.706   -290.36165   -290.36165 
   75000   -57926.532   -57926.532   -58257.114   -58257.114    319.72634    319.72634     45230.81     45230.81   -1919.2475   -1919.2475 
Loop time of 106.82 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.809 ns/day, 29.672 hours/ns, 9.362 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    | 106.03     | 106.03     | 106.03     |   0.0 | 99.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082964   | 0.082964   | 0.082964   |   0.0 |  0.08
Output  | 0.00014881 | 0.00014881 | 0.00014881 |   0.0 |  0.00
Modify  | 0.61767    | 0.61767    | 0.61767    |   0.0 |  0.58
Other   |            | 0.09113    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8875.00 ave        8875 max        8875 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920948.0 ave      920948 max      920948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920948
Ave neighs/atom = 115.11850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.217808180998, Press = 0.721443132730957
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -57926.532   -57926.532   -58257.114   -58257.114    319.72634    319.72634     45230.81     45230.81   -1919.2475   -1919.2475 
   76000   -57935.365   -57935.365   -58255.331   -58255.331    309.45856    309.45856    45240.066    45240.066   -3083.0248   -3083.0248 
Loop time of 109.97 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.786 ns/day, 30.547 hours/ns, 9.093 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    | 109.14     | 109.14     | 109.14     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086064   | 0.086064   | 0.086064   |   0.0 |  0.08
Output  | 0.00012823 | 0.00012823 | 0.00012823 |   0.0 |  0.00
Modify  | 0.64079    | 0.64079    | 0.64079    |   0.0 |  0.58
Other   |            | 0.09995    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8852.00 ave        8852 max        8852 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921422.0 ave      921422 max      921422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921422
Ave neighs/atom = 115.17775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.215254510524, Press = 1.23037761942645
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -57935.365   -57935.365   -58255.331   -58255.331    309.45856    309.45856    45240.066    45240.066   -3083.0248   -3083.0248 
   77000   -57929.196   -57929.196   -58252.105   -58252.105    312.30548    312.30548    45243.751    45243.751   -3286.3482   -3286.3482 
Loop time of 107.713 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.802 ns/day, 29.920 hours/ns, 9.284 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    | 106.91     | 106.91     | 106.91     |   0.0 | 99.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083763   | 0.083763   | 0.083763   |   0.0 |  0.08
Output  | 0.00013604 | 0.00013604 | 0.00013604 |   0.0 |  0.00
Modify  | 0.62278    | 0.62278    | 0.62278    |   0.0 |  0.58
Other   |            | 0.09286    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8861.00 ave        8861 max        8861 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920066.0 ave      920066 max      920066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920066
Ave neighs/atom = 115.00825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.211084559068, Press = 2.07234266799158
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -57929.196   -57929.196   -58252.105   -58252.105    312.30548    312.30548    45243.751    45243.751   -3286.3482   -3286.3482 
   78000   -57935.255   -57935.255   -58256.044   -58256.044    310.25531    310.25531    45222.558    45222.558   -1374.2122   -1374.2122 
Loop time of 109.935 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.786 ns/day, 30.537 hours/ns, 9.096 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    | 109.11     | 109.11     | 109.11     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085109   | 0.085109   | 0.085109   |   0.0 |  0.08
Output  | 0.00014004 | 0.00014004 | 0.00014004 |   0.0 |  0.00
Modify  | 0.63791    | 0.63791    | 0.63791    |   0.0 |  0.58
Other   |            | 0.09749    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8816.00 ave        8816 max        8816 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920064.0 ave      920064 max      920064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920064
Ave neighs/atom = 115.00800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.1887251196, Press = 3.14791876697497
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -57935.255   -57935.255   -58256.044   -58256.044    310.25531    310.25531    45222.558    45222.558   -1374.2122   -1374.2122 
   79000   -57932.424   -57932.424   -58255.714   -58255.714    312.67469    312.67469    45193.942    45193.942    2110.5513    2110.5513 
Loop time of 110.949 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.779 ns/day, 30.819 hours/ns, 9.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    | 110.12     | 110.12     | 110.12     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086756   | 0.086756   | 0.086756   |   0.0 |  0.08
Output  | 0.00013879 | 0.00013879 | 0.00013879 |   0.0 |  0.00
Modify  | 0.64655    | 0.64655    | 0.64655    |   0.0 |  0.58
Other   |            | 0.1001     |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8858.00 ave        8858 max        8858 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921116.0 ave      921116 max      921116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921116
Ave neighs/atom = 115.13950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.189656149323, Press = 2.37159301236454
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -57932.424   -57932.424   -58255.714   -58255.714    312.67469    312.67469    45193.942    45193.942    2110.5513    2110.5513 
   80000   -57930.849   -57930.849   -58256.291   -58256.291    314.75563    314.75563    45194.637    45194.637    1714.3503    1714.3503 
Loop time of 111.752 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.773 ns/day, 31.042 hours/ns, 8.948 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    | 110.91     | 110.91     | 110.91     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086668   | 0.086668   | 0.086668   |   0.0 |  0.08
Output  | 0.00014597 | 0.00014597 | 0.00014597 |   0.0 |  0.00
Modify  | 0.65186    | 0.65186    | 0.65186    |   0.0 |  0.58
Other   |            | 0.1019     |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8893.00 ave        8893 max        8893 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922626.0 ave      922626 max      922626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922626
Ave neighs/atom = 115.32825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.185814070361, Press = 1.66812714576554
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -57930.849   -57930.849   -58256.291   -58256.291    314.75563    314.75563    45194.637    45194.637    1714.3503    1714.3503 
   81000   -57938.145   -57938.145   -58256.264   -58256.264    307.67277    307.67277    45197.307    45197.307    1566.9594    1566.9594 
Loop time of 109.851 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.787 ns/day, 30.514 hours/ns, 9.103 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    | 109.03     | 109.03     | 109.03     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084404   | 0.084404   | 0.084404   |   0.0 |  0.08
Output  | 0.00015257 | 0.00015257 | 0.00015257 |   0.0 |  0.00
Modify  | 0.64004    | 0.64004    | 0.64004    |   0.0 |  0.58
Other   |            | 0.09847    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8810.00 ave        8810 max        8810 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922652.0 ave      922652 max      922652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922652
Ave neighs/atom = 115.33150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.180761948613, Press = 1.1682483628743
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -57938.145   -57938.145   -58256.264   -58256.264    307.67277    307.67277    45197.307    45197.307    1566.9594    1566.9594 
   82000   -57930.313   -57930.313   -58255.866   -58255.866    314.86252    314.86252    45204.523    45204.523    791.84265    791.84265 
Loop time of 107.435 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.804 ns/day, 29.843 hours/ns, 9.308 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    | 106.63     | 106.63     | 106.63     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082356   | 0.082356   | 0.082356   |   0.0 |  0.08
Output  | 0.0001426  | 0.0001426  | 0.0001426  |   0.0 |  0.00
Modify  | 0.62414    | 0.62414    | 0.62414    |   0.0 |  0.58
Other   |            | 0.09498    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8884.00 ave        8884 max        8884 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922408.0 ave      922408 max      922408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922408
Ave neighs/atom = 115.30100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.177009993195, Press = 0.669319581894208
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -57930.313   -57930.313   -58255.866   -58255.866    314.86252    314.86252    45204.523    45204.523    791.84265    791.84265 
   83000   -57940.645   -57940.645   -58261.791   -58261.791    310.60061    310.60061    45222.624    45222.624   -1404.7252   -1404.7252 
Loop time of 104.654 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.826 ns/day, 29.070 hours/ns, 9.555 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    | 103.88     | 103.88     | 103.88     |   0.0 | 99.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080625   | 0.080625   | 0.080625   |   0.0 |  0.08
Output  | 0.00016348 | 0.00016348 | 0.00016348 |   0.0 |  0.00
Modify  | 0.60645    | 0.60645    | 0.60645    |   0.0 |  0.58
Other   |            | 0.0874     |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8843.00 ave        8843 max        8843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921562.0 ave      921562 max      921562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921562
Ave neighs/atom = 115.19525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.161104352732, Press = -0.414606030480032
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -57940.645   -57940.645   -58261.791   -58261.791    310.60061    310.60061    45222.624    45222.624   -1404.7252   -1404.7252 
   84000   -57927.927   -57927.927   -58252.639   -58252.639    314.04907    314.04907    45244.979    45244.979   -3143.4376   -3143.4376 
Loop time of 110.047 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.785 ns/day, 30.569 hours/ns, 9.087 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    | 109.22     | 109.22     | 109.22     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083679   | 0.083679   | 0.083679   |   0.0 |  0.08
Output  | 0.00025094 | 0.00025094 | 0.00025094 |   0.0 |  0.00
Modify  | 0.64319    | 0.64319    | 0.64319    |   0.0 |  0.58
Other   |            | 0.09887    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8788.00 ave        8788 max        8788 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921736.0 ave      921736 max      921736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921736
Ave neighs/atom = 115.21700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.153299135995, Press = 0.516244461042585
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -57927.927   -57927.927   -58252.639   -58252.639    314.04907    314.04907    45244.979    45244.979   -3143.4376   -3143.4376 
   85000   -57929.377   -57929.377   -58257.426   -58257.426    317.27748    317.27748     45236.77     45236.77   -2348.6216   -2348.6216 
Loop time of 109.869 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.786 ns/day, 30.519 hours/ns, 9.102 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    | 109.04     | 109.04     | 109.04     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085365   | 0.085365   | 0.085365   |   0.0 |  0.08
Output  | 0.00013201 | 0.00013201 | 0.00013201 |   0.0 |  0.00
Modify  | 0.6425     | 0.6425     | 0.6425     |   0.0 |  0.58
Other   |            | 0.09875    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8835.00 ave        8835 max        8835 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920296.0 ave      920296 max      920296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920296
Ave neighs/atom = 115.03700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.159992072538, Press = 1.36550045547441
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -57929.377   -57929.377   -58257.426   -58257.426    317.27748    317.27748     45236.77     45236.77   -2348.6216   -2348.6216 
   86000    -57924.11    -57924.11   -58250.504   -58250.504    315.67594    315.67594    45230.858    45230.858   -1599.8284   -1599.8284 
Loop time of 109.379 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.790 ns/day, 30.383 hours/ns, 9.143 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    | 108.56     | 108.56     | 108.56     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084365   | 0.084365   | 0.084365   |   0.0 |  0.08
Output  | 0.00021489 | 0.00021489 | 0.00021489 |   0.0 |  0.00
Modify  | 0.63914    | 0.63914    | 0.63914    |   0.0 |  0.58
Other   |            | 0.0979     |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8836.00 ave        8836 max        8836 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921118.0 ave      921118 max      921118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921118
Ave neighs/atom = 115.13975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.16153502897, Press = 1.73176941676532
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000    -57924.11    -57924.11   -58250.504   -58250.504    315.67594    315.67594    45230.858    45230.858   -1599.8284   -1599.8284 
   87000   -57934.238   -57934.238   -58255.503   -58255.503    310.71484    310.71484    45219.301    45219.301   -715.05385   -715.05385 
Loop time of 111.118 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.778 ns/day, 30.866 hours/ns, 8.999 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    | 110.28     | 110.28     | 110.28     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086148   | 0.086148   | 0.086148   |   0.0 |  0.08
Output  | 0.00014515 | 0.00014515 | 0.00014515 |   0.0 |  0.00
Modify  | 0.64974    | 0.64974    | 0.64974    |   0.0 |  0.58
Other   |            | 0.1004     |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8844.00 ave        8844 max        8844 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921134.0 ave      921134 max      921134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921134
Ave neighs/atom = 115.14175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.177372779024, Press = 2.03171957193628
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -57934.238   -57934.238   -58255.503   -58255.503    310.71484    310.71484    45219.301    45219.301   -715.05385   -715.05385 
   88000   -57929.592   -57929.592   -58256.283   -58256.283    315.96384    315.96384    45195.005    45195.005    1640.6027    1640.6027 
Loop time of 110.974 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.779 ns/day, 30.826 hours/ns, 9.011 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    | 110.14     | 110.14     | 110.14     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085711   | 0.085711   | 0.085711   |   0.0 |  0.08
Output  | 0.00013164 | 0.00013164 | 0.00013164 |   0.0 |  0.00
Modify  | 0.64764    | 0.64764    | 0.64764    |   0.0 |  0.58
Other   |            | 0.09965    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8827.00 ave        8827 max        8827 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921622.0 ave      921622 max      921622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921622
Ave neighs/atom = 115.20275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.176941783364, Press = 2.93264110104185
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -57929.592   -57929.592   -58256.283   -58256.283    315.96384    315.96384    45195.005    45195.005    1640.6027    1640.6027 
   89000   -57933.993   -57933.993   -58255.335   -58255.335    310.79008    310.79008     45171.82     45171.82    3949.6676    3949.6676 
Loop time of 111.077 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.778 ns/day, 30.855 hours/ns, 9.003 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.24     | 110.24     | 110.24     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084659   | 0.084659   | 0.084659   |   0.0 |  0.08
Output  | 0.00014534 | 0.00014534 | 0.00014534 |   0.0 |  0.00
Modify  | 0.64864    | 0.64864    | 0.64864    |   0.0 |  0.58
Other   |            | 0.0991     |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8822.00 ave        8822 max        8822 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922538.0 ave      922538 max      922538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922538
Ave neighs/atom = 115.31725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.159499575397, Press = 2.16828373442868
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -57933.993   -57933.993   -58255.335   -58255.335    310.79008    310.79008     45171.82     45171.82    3949.6676    3949.6676 
   90000   -57931.575   -57931.575   -58254.328   -58254.328    312.15499    312.15499    45189.785    45189.785    2353.0929    2353.0929 
Loop time of 111.692 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.774 ns/day, 31.026 hours/ns, 8.953 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    | 110.85     | 110.85     | 110.85     |   0.0 | 99.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0875     | 0.0875     | 0.0875     |   0.0 |  0.08
Output  | 0.00027809 | 0.00027809 | 0.00027809 |   0.0 |  0.00
Modify  | 0.65536    | 0.65536    | 0.65536    |   0.0 |  0.59
Other   |            | 0.1037     |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8894.00 ave        8894 max        8894 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      923380.0 ave      923380 max      923380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 923380
Ave neighs/atom = 115.42250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.163020030115, Press = 1.25053978730019
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -57931.575   -57931.575   -58254.328   -58254.328    312.15499    312.15499    45189.785    45189.785    2353.0929    2353.0929 
   91000   -57936.217   -57936.217    -58256.18    -58256.18    309.45612    309.45612    45202.028    45202.028    836.65143    836.65143 
Loop time of 108.63 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.795 ns/day, 30.175 hours/ns, 9.206 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    | 107.82     | 107.82     | 107.82     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084562   | 0.084562   | 0.084562   |   0.0 |  0.08
Output  | 0.00013447 | 0.00013447 | 0.00013447 |   0.0 |  0.00
Modify  | 0.63256    | 0.63256    | 0.63256    |   0.0 |  0.58
Other   |            | 0.09642    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8872.00 ave        8872 max        8872 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922774.0 ave      922774 max      922774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922774
Ave neighs/atom = 115.34675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.165628264895, Press = 0.911800025528868
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -57936.217   -57936.217    -58256.18    -58256.18    309.45612    309.45612    45202.028    45202.028    836.65143    836.65143 
   92000   -57926.414   -57926.414   -58254.609   -58254.609    317.41799    317.41799    45217.938    45217.938   -688.15704   -688.15704 
Loop time of 106.817 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.809 ns/day, 29.671 hours/ns, 9.362 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    | 106.03     | 106.03     | 106.03     |   0.0 | 99.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081624   | 0.081624   | 0.081624   |   0.0 |  0.08
Output  | 0.00025718 | 0.00025718 | 0.00025718 |   0.0 |  0.00
Modify  | 0.61678    | 0.61678    | 0.61678    |   0.0 |  0.58
Other   |            | 0.09049    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8800.00 ave        8800 max        8800 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921914.0 ave      921914 max      921914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921914
Ave neighs/atom = 115.23925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.174541923219, Press = 0.690071739982515
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -57926.414   -57926.414   -58254.609   -58254.609    317.41799    317.41799    45217.938    45217.938   -688.15704   -688.15704 
   93000    -57937.04    -57937.04   -58257.652   -58257.652    310.08362    310.08362    45240.004    45240.004   -3236.7586   -3236.7586 
Loop time of 108.808 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.794 ns/day, 30.224 hours/ns, 9.191 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    | 108        | 108        | 108        |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083957   | 0.083957   | 0.083957   |   0.0 |  0.08
Output  | 0.0001546  | 0.0001546  | 0.0001546  |   0.0 |  0.00
Modify  | 0.63182    | 0.63182    | 0.63182    |   0.0 |  0.58
Other   |            | 0.09472    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8876.00 ave        8876 max        8876 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920972.0 ave      920972 max      920972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920972
Ave neighs/atom = 115.12150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.18176942892, Press = 0.526248098870879
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000    -57937.04    -57937.04   -58257.652   -58257.652    310.08362    310.08362    45240.004    45240.004   -3236.7586   -3236.7586 
   94000   -57926.452   -57926.452   -58252.402   -58252.402    315.24625    315.24625    45252.905    45252.905   -4307.9936   -4307.9936 
Loop time of 109.56 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.789 ns/day, 30.433 hours/ns, 9.127 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    | 108.74     | 108.74     | 108.74     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084462   | 0.084462   | 0.084462   |   0.0 |  0.08
Output  | 0.0001429  | 0.0001429  | 0.0001429  |   0.0 |  0.00
Modify  | 0.63572    | 0.63572    | 0.63572    |   0.0 |  0.58
Other   |            | 0.09657    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8909.00 ave        8909 max        8909 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      920214.0 ave      920214 max      920214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 920214
Ave neighs/atom = 115.02675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.181896004613, Press = 1.29750830916754
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -57926.452   -57926.452   -58252.402   -58252.402    315.24625    315.24625    45252.905    45252.905   -4307.9936   -4307.9936 
   95000   -57935.941   -57935.941   -58258.413   -58258.413    311.88261    311.88261    45228.736    45228.736   -2009.8837   -2009.8837 
Loop time of 108.437 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.797 ns/day, 30.121 hours/ns, 9.222 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    | 107.63     | 107.63     | 107.63     |   0.0 | 99.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082071   | 0.082071   | 0.082071   |   0.0 |  0.08
Output  | 0.00013129 | 0.00013129 | 0.00013129 |   0.0 |  0.00
Modify  | 0.62846    | 0.62846    | 0.62846    |   0.0 |  0.58
Other   |            | 0.09322    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8794.00 ave        8794 max        8794 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      919522.0 ave      919522 max      919522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 919522
Ave neighs/atom = 114.94025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.189375566567, Press = 1.84878423831173
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -57935.941   -57935.941   -58258.413   -58258.413    311.88261    311.88261    45228.736    45228.736   -2009.8837   -2009.8837 
   96000    -57928.68    -57928.68   -58255.847   -58255.847    316.42369    316.42369    45212.689    45212.689   -283.98595   -283.98595 
Loop time of 110.042 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.785 ns/day, 30.567 hours/ns, 9.087 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    | 109.22     | 109.22     | 109.22     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084347   | 0.084347   | 0.084347   |   0.0 |  0.08
Output  | 0.00014776 | 0.00014776 | 0.00014776 |   0.0 |  0.00
Modify  | 0.63997    | 0.63997    | 0.63997    |   0.0 |  0.58
Other   |            | 0.09602    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8826.00 ave        8826 max        8826 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921190.0 ave      921190 max      921190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921190
Ave neighs/atom = 115.14875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.192831269769, Press = 1.99699804408212
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000    -57928.68    -57928.68   -58255.847   -58255.847    316.42369    316.42369    45212.689    45212.689   -283.98595   -283.98595 
   97000   -57938.853   -57938.853   -58260.598   -58260.598    311.17902    311.17902     45192.91     45192.91    1576.7271    1576.7271 
Loop time of 109.754 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.787 ns/day, 30.487 hours/ns, 9.111 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    | 108.93     | 108.93     | 108.93     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08553    | 0.08553    | 0.08553    |   0.0 |  0.08
Output  | 0.00013176 | 0.00013176 | 0.00013176 |   0.0 |  0.00
Modify  | 0.63753    | 0.63753    | 0.63753    |   0.0 |  0.58
Other   |            | 0.09694    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8914.00 ave        8914 max        8914 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      921576.0 ave      921576 max      921576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 921576
Ave neighs/atom = 115.19700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.185451076691, Press = 1.85387852614935
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -57938.853   -57938.853   -58260.598   -58260.598    311.17902    311.17902     45192.91     45192.91    1576.7271    1576.7271 
   98000   -57930.075   -57930.075   -58254.516   -58254.516    313.78755    313.78755    45187.225    45187.225    2452.8588    2452.8588 
Loop time of 110.666 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.781 ns/day, 30.741 hours/ns, 9.036 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    | 109.84     | 109.84     | 109.84     |   0.0 | 99.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084489   | 0.084489   | 0.084489   |   0.0 |  0.08
Output  | 0.00015061 | 0.00015061 | 0.00015061 |   0.0 |  0.00
Modify  | 0.64281    | 0.64281    | 0.64281    |   0.0 |  0.58
Other   |            | 0.09763    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8823.00 ave        8823 max        8823 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922392.0 ave      922392 max      922392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922392
Ave neighs/atom = 115.29900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.176833957805, Press = 1.4476865641303
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -57930.075   -57930.075   -58254.516   -58254.516    313.78755    313.78755    45187.225    45187.225    2452.8588    2452.8588 
   99000   -57933.759   -57933.759   -58258.341   -58258.341    313.92393    313.92393    45180.031    45180.031    3254.4249    3254.4249 
Loop time of 108.417 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.797 ns/day, 30.116 hours/ns, 9.224 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    | 107.61     | 107.61     | 107.61     |   0.0 | 99.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08309    | 0.08309    | 0.08309    |   0.0 |  0.08
Output  | 0.00026429 | 0.00026429 | 0.00026429 |   0.0 |  0.00
Modify  | 0.62651    | 0.62651    | 0.62651    |   0.0 |  0.58
Other   |            | 0.09377    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8867.00 ave        8867 max        8867 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      922662.0 ave      922662 max      922662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 922662
Ave neighs/atom = 115.33275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.175545793553, Press = 0.767972932319307
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.3
  ghost atom cutoff = 5.3
  binsize = 2.65, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.300000000000001
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 12.72 | 12.72 | 12.72 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -57933.759   -57933.759   -58258.341   -58258.341    313.92393    313.92393    45180.031    45180.031    3254.4249    3254.4249 
  100000   -57922.824   -57922.824   -58250.482   -58250.482    316.89847    316.89847    45197.172    45197.172    1646.8416    1646.8416 
Loop time of 100.68 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.858 ns/day, 27.967 hours/ns, 9.932 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    | 99.937     | 99.937     | 99.937     |   0.0 | 99.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077644   | 0.077644   | 0.077644   |   0.0 |  0.08
Output  | 0.0001314  | 0.0001314  | 0.0001314  |   0.0 |  0.00
Modify  | 0.58054    | 0.58054    | 0.58054    |   0.0 |  0.58
Other   |            | 0.08423    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8894.00 ave        8894 max        8894 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      923132.0 ave      923132 max      923132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 923132
Ave neighs/atom = 115.39150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
45210.7556434365

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0