# 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.302443556487561*${_u_distance}
variable latticeconst_converted equal 3.302443556487561*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.30244355648756
Lattice spacing in x,y,z = 3.3024436 3.3024436 3.3024436
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 (33.024436 33.024436 33.024436)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (33.024436 33.024436 33.024436)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Ta

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

kim interactions Ta
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeBaskesKim_2001_Ta__MO_644143102837_000
pair_coeff * * Ta
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 180.9479

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -16104.253   -16104.253       -16180       -16180       293.15       293.15     36016.89     36016.89    2246.3474    2246.3474 
    1000   -16024.624   -16024.624   -16092.417   -16092.417    262.36477    262.36477    36075.755    36075.755    7084.1976    7084.1976 
Loop time of 99.9307 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.865 ns/day, 27.759 hours/ns, 10.007 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.424     | 99.424     | 99.424     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077977   | 0.077977   | 0.077977   |   0.0 |  0.08
Output  | 0.00019617 | 0.00019617 | 0.00019617 |   0.0 |  0.00
Modify  | 0.37033    | 0.37033    | 0.37033    |   0.0 |  0.37
Other   |            | 0.05812    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116000.0 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -16024.624   -16024.624   -16092.417   -16092.417    262.36477    262.36477    36075.755    36075.755    7084.1976    7084.1976 
    2000    -16024.69    -16024.69   -16102.718   -16102.718    301.97393    301.97393    36205.354    36205.354   -814.51516   -814.51516 
Loop time of 101.117 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.854 ns/day, 28.088 hours/ns, 9.890 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.62     | 100.62     | 100.62     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076417   | 0.076417   | 0.076417   |   0.0 |  0.08
Output  | 0.00019052 | 0.00019052 | 0.00019052 |   0.0 |  0.00
Modify  | 0.3581     | 0.3581     | 0.3581     |   0.0 |  0.35
Other   |            | 0.05729    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.820 ns/day, 29.274 hours/ns, 9.489 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.86     | 104.86     | 104.86     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078754   | 0.078754   | 0.078754   |   0.0 |  0.07
Output  | 0.00023017 | 0.00023017 | 0.00023017 |   0.0 |  0.00
Modify  | 0.38388    | 0.38388    | 0.38388    |   0.0 |  0.36
Other   |            | 0.05951    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.799 ns/day, 30.022 hours/ns, 9.253 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.54     | 107.54     | 107.54     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080604   | 0.080604   | 0.080604   |   0.0 |  0.07
Output  | 0.00019267 | 0.00019267 | 0.00019267 |   0.0 |  0.00
Modify  | 0.39609    | 0.39609    | 0.39609    |   0.0 |  0.37
Other   |            | 0.06076    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.825 ns/day, 29.104 hours/ns, 9.544 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.25     | 104.25     | 104.25     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079201   | 0.079201   | 0.079201   |   0.0 |  0.08
Output  | 0.00015252 | 0.00015252 | 0.00015252 |   0.0 |  0.00
Modify  | 0.3818     | 0.3818     | 0.3818     |   0.0 |  0.36
Other   |            | 0.05894    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 284.925458187751, Press = -173.003508404478
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -16026.499   -16026.499    -16105.12    -16105.12    304.26817    304.26817    36194.798    36194.798   -427.41526   -427.41526 
    6000   -16026.833   -16026.833   -16103.042   -16103.042    294.93971    294.93971    36150.378    36150.378    2176.4256    2176.4256 
Loop time of 107.911 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.801 ns/day, 29.975 hours/ns, 9.267 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.36     | 107.36     | 107.36     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080891   | 0.080891   | 0.080891   |   0.0 |  0.07
Output  | 0.0001534  | 0.0001534  | 0.0001534  |   0.0 |  0.00
Modify  | 0.41444    | 0.41444    | 0.41444    |   0.0 |  0.38
Other   |            | 0.0603     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.203854353008, Press = 6.27362997913449
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -16026.833   -16026.833   -16103.042   -16103.042    294.93971    294.93971    36150.378    36150.378    2176.4256    2176.4256 
    7000    -16027.62    -16027.62    -16099.43    -16099.43    277.91115    277.91115    36210.762    36210.762   -899.10086   -899.10086 
Loop time of 104.766 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.102 hours/ns, 9.545 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.23     | 104.23     | 104.23     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079905   | 0.079905   | 0.079905   |   0.0 |  0.08
Output  | 0.00019987 | 0.00019987 | 0.00019987 |   0.0 |  0.00
Modify  | 0.39702    | 0.39702    | 0.39702    |   0.0 |  0.38
Other   |            | 0.05969    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.642994118022, Press = 11.1695044998401
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000    -16027.62    -16027.62    -16099.43    -16099.43    277.91115    277.91115    36210.762    36210.762   -899.10086   -899.10086 
    8000   -16026.729   -16026.729   -16105.693   -16105.693    305.60011    305.60011    36223.299    36223.299   -2080.0118   -2080.0118 
Loop time of 105.696 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.360 hours/ns, 9.461 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.16     | 105.16     | 105.16     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080228   | 0.080228   | 0.080228   |   0.0 |  0.08
Output  | 0.00019476 | 0.00019476 | 0.00019476 |   0.0 |  0.00
Modify  | 0.40069    | 0.40069    | 0.40069    |   0.0 |  0.38
Other   |            | 0.05941    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115966.0 ave      115966 max      115966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115966
Ave neighs/atom = 57.983000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.32395406105, Press = -10.1184918289189
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -16026.729   -16026.729   -16105.693   -16105.693    305.60011    305.60011    36223.299    36223.299   -2080.0118   -2080.0118 
    9000   -16024.836   -16024.836   -16101.017   -16101.017    294.82847    294.82847    36188.607    36188.607    252.21619    252.21619 
Loop time of 107.507 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.863 hours/ns, 9.302 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.95     | 106.95     | 106.95     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080659   | 0.080659   | 0.080659   |   0.0 |  0.08
Output  | 0.00015331 | 0.00015331 | 0.00015331 |   0.0 |  0.00
Modify  | 0.41462    | 0.41462    | 0.41462    |   0.0 |  0.39
Other   |            | 0.06087    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.688824100341, Press = -5.22085316219835
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -16024.836   -16024.836   -16101.017   -16101.017    294.82847    294.82847    36188.607    36188.607    252.21619    252.21619 
   10000   -16027.796   -16027.796   -16100.343   -16100.343    280.76571    280.76571    36227.271    36227.271   -2080.4051   -2080.4051 
Loop time of 105.74 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.372 hours/ns, 9.457 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.2      | 105.2      | 105.2      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079648   | 0.079648   | 0.079648   |   0.0 |  0.08
Output  | 0.00015475 | 0.00015475 | 0.00015475 |   0.0 |  0.00
Modify  | 0.40402    | 0.40402    | 0.40402    |   0.0 |  0.38
Other   |            | 0.06017    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.594266261881, Press = -6.84348735039222
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -16027.796   -16027.796   -16100.343   -16100.343    280.76571    280.76571    36227.271    36227.271   -2080.4051   -2080.4051 
   11000   -16027.506   -16027.506   -16103.844   -16103.844    295.43873    295.43873    36142.993    36142.993    2667.1541    2667.1541 
Loop time of 108.104 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.799 ns/day, 30.029 hours/ns, 9.250 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.55     | 107.55     | 107.55     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080783   | 0.080783   | 0.080783   |   0.0 |  0.07
Output  | 0.00021443 | 0.00021443 | 0.00021443 |   0.0 |  0.00
Modify  | 0.41267    | 0.41267    | 0.41267    |   0.0 |  0.38
Other   |            | 0.06096    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115970.0 ave      115970 max      115970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115970
Ave neighs/atom = 57.985000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.82169879709, Press = 3.42946781503225
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -16027.506   -16027.506   -16103.844   -16103.844    295.43873    295.43873    36142.993    36142.993    2667.1541    2667.1541 
   12000   -16025.641   -16025.641   -16106.204   -16106.204    311.78875    311.78875    36216.572    36216.572   -1504.1555   -1504.1555 
Loop time of 106.348 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.541 hours/ns, 9.403 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.8      | 105.8      | 105.8      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080091   | 0.080091   | 0.080091   |   0.0 |  0.08
Output  | 0.0001567  | 0.0001567  | 0.0001567  |   0.0 |  0.00
Modify  | 0.40705    | 0.40705    | 0.40705    |   0.0 |  0.38
Other   |            | 0.06022    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.628622172301, Press = 2.53966368424352
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -16025.641   -16025.641   -16106.204   -16106.204    311.78875    311.78875    36216.572    36216.572   -1504.1555   -1504.1555 
   13000   -16028.374   -16028.374    -16103.13    -16103.13    289.31276    289.31276    36171.846    36171.846    978.86417    978.86417 
Loop time of 105.247 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.235 hours/ns, 9.501 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.7      | 104.7      | 104.7      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079967   | 0.079967   | 0.079967   |   0.0 |  0.08
Output  | 0.00015573 | 0.00015573 | 0.00015573 |   0.0 |  0.00
Modify  | 0.40283    | 0.40283    | 0.40283    |   0.0 |  0.38
Other   |            | 0.05998    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.677396472369, Press = -1.04874606757898
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -16028.374   -16028.374    -16103.13    -16103.13    289.31276    289.31276    36171.846    36171.846    978.86417    978.86417 
   14000   -16024.022   -16024.022   -16103.097   -16103.097    306.02844    306.02844    36188.414    36188.414    187.92133    187.92133 
Loop time of 103.798 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.833 hours/ns, 9.634 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.27     | 103.27     | 103.27     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078895   | 0.078895   | 0.078895   |   0.0 |  0.08
Output  | 0.00015375 | 0.00015375 | 0.00015375 |   0.0 |  0.00
Modify  | 0.39377    | 0.39377    | 0.39377    |   0.0 |  0.38
Other   |            | 0.05907    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115994.0 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.961701005161, Press = 2.42638236332136
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -16024.022   -16024.022   -16103.097   -16103.097    306.02844    306.02844    36188.414    36188.414    187.92133    187.92133 
   15000    -16029.23    -16029.23   -16103.063   -16103.063    285.74364    285.74364    36222.158    36222.158   -1689.8772   -1689.8772 
Loop time of 104.786 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.107 hours/ns, 9.543 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.25     | 104.25     | 104.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079143   | 0.079143   | 0.079143   |   0.0 |  0.08
Output  | 0.00015315 | 0.00015315 | 0.00015315 |   0.0 |  0.00
Modify  | 0.40059    | 0.40059    | 0.40059    |   0.0 |  0.38
Other   |            | 0.05958    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115970.0 ave      115970 max      115970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115970
Ave neighs/atom = 57.985000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.824489341145, Press = -0.0984578433784542
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -16029.23    -16029.23   -16103.063   -16103.063    285.74364    285.74364    36222.158    36222.158   -1689.8772   -1689.8772 
   16000   -16026.877   -16026.877   -16098.162   -16098.162    275.87932    275.87932    36245.806    36245.806   -2716.8334   -2716.8334 
Loop time of 106.35 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.542 hours/ns, 9.403 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.8      | 105.8      | 105.8      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079983   | 0.079983   | 0.079983   |   0.0 |  0.08
Output  | 0.0001832  | 0.0001832  | 0.0001832  |   0.0 |  0.00
Modify  | 0.40606    | 0.40606    | 0.40606    |   0.0 |  0.38
Other   |            | 0.06054    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115992.0 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.691465096195, Press = 2.71554628390162
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -16026.877   -16026.877   -16098.162   -16098.162    275.87932    275.87932    36245.806    36245.806   -2716.8334   -2716.8334 
   17000   -16027.185   -16027.185   -16106.225   -16106.225    305.89177    305.89177     36212.37     36212.37   -1377.6541   -1377.6541 
Loop time of 105.897 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.416 hours/ns, 9.443 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.35     | 105.35     | 105.35     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080248   | 0.080248   | 0.080248   |   0.0 |  0.08
Output  | 0.00021527 | 0.00021527 | 0.00021527 |   0.0 |  0.00
Modify  | 0.40674    | 0.40674    | 0.40674    |   0.0 |  0.38
Other   |            | 0.06016    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115960.0 ave      115960 max      115960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115960
Ave neighs/atom = 57.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.697432560902, Press = 7.21958247804284e-06
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -16027.185   -16027.185   -16106.225   -16106.225    305.89177    305.89177     36212.37     36212.37   -1377.6541   -1377.6541 
   18000   -16024.572   -16024.572   -16104.335   -16104.335    308.69093    308.69093     36221.79     36221.79   -1657.2192   -1657.2192 
Loop time of 105.932 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.425 hours/ns, 9.440 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.39     | 105.39     | 105.39     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079514   | 0.079514   | 0.079514   |   0.0 |  0.08
Output  | 0.00020537 | 0.00020537 | 0.00020537 |   0.0 |  0.00
Modify  | 0.40252    | 0.40252    | 0.40252    |   0.0 |  0.38
Other   |            | 0.06012    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.739794548076, Press = -4.47723073883476
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -16024.572   -16024.572   -16104.335   -16104.335    308.69093    308.69093     36221.79     36221.79   -1657.2192   -1657.2192 
   19000   -16027.819   -16027.819   -16105.989   -16105.989      302.526      302.526    36193.245    36193.245   -222.40936   -222.40936 
Loop time of 106.846 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.679 hours/ns, 9.359 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.29     | 106.29     | 106.29     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081032   | 0.081032   | 0.081032   |   0.0 |  0.08
Output  | 0.00019871 | 0.00019871 | 0.00019871 |   0.0 |  0.00
Modify  | 0.41295    | 0.41295    | 0.41295    |   0.0 |  0.39
Other   |            | 0.06035    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.871881496351, Press = 0.0562575801657663
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -16027.819   -16027.819   -16105.989   -16105.989      302.526      302.526    36193.245    36193.245   -222.40936   -222.40936 
   20000   -16029.567   -16029.567   -16103.103   -16103.103    284.59187    284.59187     36198.48     36198.48   -501.06382   -501.06382 
Loop time of 106.8 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.667 hours/ns, 9.363 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.25     | 106.25     | 106.25     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080624   | 0.080624   | 0.080624   |   0.0 |  0.08
Output  | 0.00021981 | 0.00021981 | 0.00021981 |   0.0 |  0.00
Modify  | 0.40894    | 0.40894    | 0.40894    |   0.0 |  0.38
Other   |            | 0.06045    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115994.0 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.743498973934, Press = 0.923946162665654
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -16029.567   -16029.567   -16103.103   -16103.103    284.59187    284.59187     36198.48     36198.48   -501.06382   -501.06382 
   21000   -16026.297   -16026.297   -16099.298   -16099.298    282.52015    282.52015    36207.563    36207.563    -683.8439    -683.8439 
Loop time of 107.992 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.800 ns/day, 29.998 hours/ns, 9.260 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.43     | 107.43     | 107.43     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081315   | 0.081315   | 0.081315   |   0.0 |  0.08
Output  | 0.00019715 | 0.00019715 | 0.00019715 |   0.0 |  0.00
Modify  | 0.41546    | 0.41546    | 0.41546    |   0.0 |  0.38
Other   |            | 0.06063    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.704505041011, Press = 2.46214642156304
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -16026.297   -16026.297   -16099.298   -16099.298    282.52015    282.52015    36207.563    36207.563    -683.8439    -683.8439 
   22000   -16028.846   -16028.846   -16104.026   -16104.026    290.95346    290.95346    36278.687    36278.687   -4770.8235   -4770.8235 
Loop time of 105.998 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.444 hours/ns, 9.434 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.45     | 105.45     | 105.45     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07992    | 0.07992    | 0.07992    |   0.0 |  0.08
Output  | 0.00015742 | 0.00015742 | 0.00015742 |   0.0 |  0.00
Modify  | 0.40339    | 0.40339    | 0.40339    |   0.0 |  0.38
Other   |            | 0.06007    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.659208728755, Press = 2.88094470242647
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -16028.846   -16028.846   -16104.026   -16104.026    290.95346    290.95346    36278.687    36278.687   -4770.8235   -4770.8235 
   23000    -16028.11    -16028.11   -16101.972   -16101.972    285.85056    285.85056    36220.546    36220.546   -1571.6762   -1571.6762 
Loop time of 107.538 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.803 ns/day, 29.872 hours/ns, 9.299 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.98     | 106.98     | 106.98     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081266   | 0.081266   | 0.081266   |   0.0 |  0.08
Output  | 0.0001921  | 0.0001921  | 0.0001921  |   0.0 |  0.00
Modify  | 0.41569    | 0.41569    | 0.41569    |   0.0 |  0.39
Other   |            | 0.06116    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.468148141014, Press = 2.14078539435694
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000    -16028.11    -16028.11   -16101.972   -16101.972    285.85056    285.85056    36220.546    36220.546   -1571.6762   -1571.6762 
   24000   -16026.091   -16026.091   -16103.259   -16103.259    298.64757    298.64757    36216.067    36216.067   -1284.3417   -1284.3417 
Loop time of 103.034 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.620 hours/ns, 9.706 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.51     | 102.51     | 102.51     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078268   | 0.078268   | 0.078268   |   0.0 |  0.08
Output  | 0.00023879 | 0.00023879 | 0.00023879 |   0.0 |  0.00
Modify  | 0.38917    | 0.38917    | 0.38917    |   0.0 |  0.38
Other   |            | 0.05858    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.41795779067, Press = -0.0358601178064686
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -16026.091   -16026.091   -16103.259   -16103.259    298.64757    298.64757    36216.067    36216.067   -1284.3417   -1284.3417 
   25000   -16026.855   -16026.855   -16104.648   -16104.648    301.06535    301.06535    36192.221    36192.221   -170.47537   -170.47537 
Loop time of 103.92 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.867 hours/ns, 9.623 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.39     | 103.39     | 103.39     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078806   | 0.078806   | 0.078806   |   0.0 |  0.08
Output  | 0.00015302 | 0.00015302 | 0.00015302 |   0.0 |  0.00
Modify  | 0.3958     | 0.3958     | 0.3958     |   0.0 |  0.38
Other   |            | 0.0591     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.438418183666, Press = -0.257375838300251
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -16026.855   -16026.855   -16104.648   -16104.648    301.06535    301.06535    36192.221    36192.221   -170.47537   -170.47537 
   26000   -16026.288   -16026.288   -16101.313   -16101.313    290.35431    290.35431    36168.885    36168.885    1389.8595    1389.8595 
Loop time of 101.721 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.849 ns/day, 28.256 hours/ns, 9.831 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.2      | 101.2      | 101.2      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076991   | 0.076991   | 0.076991   |   0.0 |  0.08
Output  | 0.0002165  | 0.0002165  | 0.0002165  |   0.0 |  0.00
Modify  | 0.38275    | 0.38275    | 0.38275    |   0.0 |  0.38
Other   |            | 0.05776    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.466159050183, Press = 0.446020902466317
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -16026.288   -16026.288   -16101.313   -16101.313    290.35431    290.35431    36168.885    36168.885    1389.8595    1389.8595 
   27000   -16025.178   -16025.178   -16102.439   -16102.439    299.00778    299.00778    36206.469    36206.469   -835.68499   -835.68499 
Loop time of 106.392 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.553 hours/ns, 9.399 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.84     | 105.84     | 105.84     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080066   | 0.080066   | 0.080066   |   0.0 |  0.08
Output  | 0.00018674 | 0.00018674 | 0.00018674 |   0.0 |  0.00
Modify  | 0.40752    | 0.40752    | 0.40752    |   0.0 |  0.38
Other   |            | 0.06074    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.537708744419, Press = -1.71093813975046
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -16025.178   -16025.178   -16102.439   -16102.439    299.00778    299.00778    36206.469    36206.469   -835.68499   -835.68499 
   28000   -16029.685   -16029.685   -16102.162   -16102.162    280.49308    280.49308    36198.062    36198.062   -331.21154   -331.21154 
Loop time of 105.516 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.310 hours/ns, 9.477 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.98     | 104.98     | 104.98     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08008    | 0.08008    | 0.08008    |   0.0 |  0.08
Output  | 0.00020783 | 0.00020783 | 0.00020783 |   0.0 |  0.00
Modify  | 0.40044    | 0.40044    | 0.40044    |   0.0 |  0.38
Other   |            | 0.05978    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.69405752749, Press = -0.749856883560373
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -16029.685   -16029.685   -16102.162   -16102.162    280.49308    280.49308    36198.062    36198.062   -331.21154   -331.21154 
   29000   -16026.019   -16026.019   -16100.841   -16100.841    289.56766    289.56766    36204.027    36204.027   -550.40574   -550.40574 
Loop time of 104.95 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.153 hours/ns, 9.528 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.41     | 104.41     | 104.41     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079222   | 0.079222   | 0.079222   |   0.0 |  0.08
Output  | 0.00019632 | 0.00019632 | 0.00019632 |   0.0 |  0.00
Modify  | 0.39963    | 0.39963    | 0.39963    |   0.0 |  0.38
Other   |            | 0.05996    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.69094535657, Press = 0.0336300933071605
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -16026.019   -16026.019   -16100.841   -16100.841    289.56766    289.56766    36204.027    36204.027   -550.40574   -550.40574 
   30000   -16031.348   -16031.348   -16105.207   -16105.207     285.8434     285.8434    36147.309    36147.309    2088.2403    2088.2403 
Loop time of 105.144 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.207 hours/ns, 9.511 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.6      | 104.6      | 104.6      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080376   | 0.080376   | 0.080376   |   0.0 |  0.08
Output  | 0.00046759 | 0.00046759 | 0.00046759 |   0.0 |  0.00
Modify  | 0.40287    | 0.40287    | 0.40287    |   0.0 |  0.38
Other   |            | 0.05975    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.69689593746, Press = 1.28493346031362
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -16031.348   -16031.348   -16105.207   -16105.207     285.8434     285.8434    36147.309    36147.309    2088.2403    2088.2403 
   31000   -16027.043   -16027.043   -16101.397   -16101.397     287.7591     287.7591     36169.68     36169.68    1261.8994    1261.8994 
Loop time of 104.952 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.153 hours/ns, 9.528 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.41     | 104.41     | 104.41     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079057   | 0.079057   | 0.079057   |   0.0 |  0.08
Output  | 0.00018647 | 0.00018647 | 0.00018647 |   0.0 |  0.00
Modify  | 0.3988     | 0.3988     | 0.3988     |   0.0 |  0.38
Other   |            | 0.06022    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.696653449803, Press = 1.13514752631616
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -16027.043   -16027.043   -16101.397   -16101.397     287.7591     287.7591     36169.68     36169.68    1261.8994    1261.8994 
   32000    -16031.69    -16031.69   -16104.027   -16104.027    279.94972    279.94972    36114.179    36114.179    3916.9403    3916.9403 
Loop time of 103.706 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.807 hours/ns, 9.643 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.17     | 103.17     | 103.17     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078786   | 0.078786   | 0.078786   |   0.0 |  0.08
Output  | 0.00015831 | 0.00015831 | 0.00015831 |   0.0 |  0.00
Modify  | 0.39497    | 0.39497    | 0.39497    |   0.0 |  0.38
Other   |            | 0.05936    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.587689695917, Press = 2.34867723875661
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    -16031.69    -16031.69   -16104.027   -16104.027    279.94972    279.94972    36114.179    36114.179    3916.9403    3916.9403 
   33000   -16026.235   -16026.235   -16102.327   -16102.327    294.48545    294.48545    36119.727    36119.727    3827.8611    3827.8611 
Loop time of 105.727 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.369 hours/ns, 9.458 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.18     | 105.18     | 105.18     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080418   | 0.080418   | 0.080418   |   0.0 |  0.08
Output  | 0.00020098 | 0.00020098 | 0.00020098 |   0.0 |  0.00
Modify  | 0.40355    | 0.40355    | 0.40355    |   0.0 |  0.38
Other   |            | 0.05986    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.570140352243, Press = 2.5087847536058
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -16026.235   -16026.235   -16102.327   -16102.327    294.48545    294.48545    36119.727    36119.727    3827.8611    3827.8611 
   34000   -16028.822   -16028.822   -16099.749   -16099.749    274.49592    274.49592    36188.434    36188.434     265.1106     265.1106 
Loop time of 102.425 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.451 hours/ns, 9.763 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.9      | 101.9      | 101.9      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077667   | 0.077667   | 0.077667   |   0.0 |  0.08
Output  | 0.00015474 | 0.00015474 | 0.00015474 |   0.0 |  0.00
Modify  | 0.38953    | 0.38953    | 0.38953    |   0.0 |  0.38
Other   |            | 0.05903    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.563881397455, Press = 1.48887760900453
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -16028.822   -16028.822   -16099.749   -16099.749    274.49592    274.49592    36188.434    36188.434     265.1106     265.1106 
   35000   -16026.325   -16026.325   -16099.459   -16099.459    283.03783    283.03783    36187.959    36187.959    355.14225    355.14225 
Loop time of 103.018 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.616 hours/ns, 9.707 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.49     | 102.49     | 102.49     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078845   | 0.078845   | 0.078845   |   0.0 |  0.08
Output  | 0.00015474 | 0.00015474 | 0.00015474 |   0.0 |  0.00
Modify  | 0.39181    | 0.39181    | 0.39181    |   0.0 |  0.38
Other   |            | 0.059      |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.514626156016, Press = 1.80281082407498
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -16026.325   -16026.325   -16099.459   -16099.459    283.03783    283.03783    36187.959    36187.959    355.14225    355.14225 
   36000   -16028.674   -16028.674   -16104.802   -16104.802    294.62229    294.62229    36195.361    36195.361   -370.17479   -370.17479 
Loop time of 103.914 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.865 hours/ns, 9.623 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.38     | 103.38     | 103.38     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079057   | 0.079057   | 0.079057   |   0.0 |  0.08
Output  | 0.00015271 | 0.00015271 | 0.00015271 |   0.0 |  0.00
Modify  | 0.39472    | 0.39472    | 0.39472    |   0.0 |  0.38
Other   |            | 0.05953    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.484662006609, Press = 2.272992568016
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -16028.674   -16028.674   -16104.802   -16104.802    294.62229    294.62229    36195.361    36195.361   -370.17479   -370.17479 
   37000   -16025.979   -16025.979   -16101.342   -16101.342     291.6613     291.6613    36182.248    36182.248    643.60605    643.60605 
Loop time of 104.978 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.161 hours/ns, 9.526 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.44     | 104.44     | 104.44     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079578   | 0.079578   | 0.079578   |   0.0 |  0.08
Output  | 0.0001485  | 0.0001485  | 0.0001485  |   0.0 |  0.00
Modify  | 0.39946    | 0.39946    | 0.39946    |   0.0 |  0.38
Other   |            | 0.0601     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.514566161193, Press = 1.33710325668636
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -16025.979   -16025.979   -16101.342   -16101.342     291.6613     291.6613    36182.248    36182.248    643.60605    643.60605 
   38000   -16024.757   -16024.757   -16100.378   -16100.378    292.65973    292.65973    36138.973    36138.973    2974.5591    2974.5591 
Loop time of 102.128 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.846 ns/day, 28.369 hours/ns, 9.792 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.6      | 101.6      | 101.6      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078246   | 0.078246   | 0.078246   |   0.0 |  0.08
Output  | 0.00015419 | 0.00015419 | 0.00015419 |   0.0 |  0.00
Modify  | 0.38827    | 0.38827    | 0.38827    |   0.0 |  0.38
Other   |            | 0.05833    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.565618599845, Press = 2.93681512736057
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -16024.757   -16024.757   -16100.378   -16100.378    292.65973    292.65973    36138.973    36138.973    2974.5591    2974.5591 
   39000   -16027.299   -16027.299   -16101.725   -16101.725    288.03875    288.03875    36157.341    36157.341    1862.7717    1862.7717 
Loop time of 106.878 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.688 hours/ns, 9.356 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.32     | 106.32     | 106.32     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080681   | 0.080681   | 0.080681   |   0.0 |  0.08
Output  | 0.0001533  | 0.0001533  | 0.0001533  |   0.0 |  0.00
Modify  | 0.41213    | 0.41213    | 0.41213    |   0.0 |  0.39
Other   |            | 0.06132    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.583389672873, Press = 2.26379883162712
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -16027.299   -16027.299   -16101.725   -16101.725    288.03875    288.03875    36157.341    36157.341    1862.7717    1862.7717 
   40000   -16026.592   -16026.592   -16101.529   -16101.529    290.01345    290.01345    36210.845    36210.845   -1043.5115   -1043.5115 
Loop time of 105.861 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.406 hours/ns, 9.446 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.32     | 105.32     | 105.32     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079318   | 0.079318   | 0.079318   |   0.0 |  0.07
Output  | 0.00021343 | 0.00021343 | 0.00021343 |   0.0 |  0.00
Modify  | 0.40461    | 0.40461    | 0.40461    |   0.0 |  0.38
Other   |            | 0.05979    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115970.0 ave      115970 max      115970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115970
Ave neighs/atom = 57.985000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.605283715775, Press = 1.84602517885111
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -16026.592   -16026.592   -16101.529   -16101.529    290.01345    290.01345    36210.845    36210.845   -1043.5115   -1043.5115 
   41000   -16025.495   -16025.495   -16102.745   -16102.745    298.96489    298.96489    36196.716    36196.716   -294.61629   -294.61629 
Loop time of 107.757 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.933 hours/ns, 9.280 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.2      | 107.2      | 107.2      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081689   | 0.081689   | 0.081689   |   0.0 |  0.08
Output  | 0.00023828 | 0.00023828 | 0.00023828 |   0.0 |  0.00
Modify  | 0.41275    | 0.41275    | 0.41275    |   0.0 |  0.38
Other   |            | 0.06062    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.658834969343, Press = 0.747422677841874
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -16025.495   -16025.495   -16102.745   -16102.745    298.96489    298.96489    36196.716    36196.716   -294.61629   -294.61629 
   42000   -16024.352   -16024.352   -16098.899   -16098.899    288.50706    288.50706    36176.369    36176.369    1090.0763    1090.0763 
Loop time of 108.723 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.795 ns/day, 30.201 hours/ns, 9.198 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.16     | 108.16     | 108.16     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081903   | 0.081903   | 0.081903   |   0.0 |  0.08
Output  | 0.00024684 | 0.00024684 | 0.00024684 |   0.0 |  0.00
Modify  | 0.41958    | 0.41958    | 0.41958    |   0.0 |  0.39
Other   |            | 0.06165    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.687196339875, Press = 2.44613351071324
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -16024.352   -16024.352   -16098.899   -16098.899    288.50706    288.50706    36176.369    36176.369    1090.0763    1090.0763 
   43000   -16028.458   -16028.458   -16102.574   -16102.574     286.8381     286.8381    36193.167    36193.167   -230.83712   -230.83712 
Loop time of 106.074 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.465 hours/ns, 9.427 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.53     | 105.53     | 105.53     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080588   | 0.080588   | 0.080588   |   0.0 |  0.08
Output  | 0.00015511 | 0.00015511 | 0.00015511 |   0.0 |  0.00
Modify  | 0.40721    | 0.40721    | 0.40721    |   0.0 |  0.38
Other   |            | 0.06066    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.71025333938, Press = 1.68293220997024
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -16028.458   -16028.458   -16102.574   -16102.574     286.8381     286.8381    36193.167    36193.167   -230.83712   -230.83712 
   44000   -16026.286   -16026.286   -16102.306   -16102.306    294.20371    294.20371    36180.271    36180.271    654.94547    654.94547 
Loop time of 107.765 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.935 hours/ns, 9.279 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.21     | 107.21     | 107.21     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080602   | 0.080602   | 0.080602   |   0.0 |  0.07
Output  | 0.0002227  | 0.0002227  | 0.0002227  |   0.0 |  0.00
Modify  | 0.41069    | 0.41069    | 0.41069    |   0.0 |  0.38
Other   |            | 0.06046    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.665752912376, Press = 1.84772743483133
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -16026.286   -16026.286   -16102.306   -16102.306    294.20371    294.20371    36180.271    36180.271    654.94547    654.94547 
   45000   -16026.738   -16026.738   -16103.825   -16103.825    298.33387    298.33387    36208.479    36208.479   -923.31932   -923.31932 
Loop time of 104.875 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.132 hours/ns, 9.535 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.33     | 104.33     | 104.33     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080448   | 0.080448   | 0.080448   |   0.0 |  0.08
Output  | 0.0001902  | 0.0001902  | 0.0001902  |   0.0 |  0.00
Modify  | 0.40646    | 0.40646    | 0.40646    |   0.0 |  0.39
Other   |            | 0.05993    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.653556213048, Press = 1.18895489185812
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -16026.738   -16026.738   -16103.825   -16103.825    298.33387    298.33387    36208.479    36208.479   -923.31932   -923.31932 
   46000   -16027.235   -16027.235   -16102.752   -16102.752    292.25857    292.25857    36204.479    36204.479   -649.88638   -649.88638 
Loop time of 107.716 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.921 hours/ns, 9.284 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.16     | 107.16     | 107.16     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081872   | 0.081872   | 0.081872   |   0.0 |  0.08
Output  | 0.00020266 | 0.00020266 | 0.00020266 |   0.0 |  0.00
Modify  | 0.4129     | 0.4129     | 0.4129     |   0.0 |  0.38
Other   |            | 0.06115    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.625828111634, Press = 1.41265975877946
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -16027.235   -16027.235   -16102.752   -16102.752    292.25857    292.25857    36204.479    36204.479   -649.88638   -649.88638 
   47000   -16026.421   -16026.421   -16100.992   -16100.992    288.59634    288.59634    36225.424    36225.424   -1715.9132   -1715.9132 
Loop time of 100.347 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.861 ns/day, 27.874 hours/ns, 9.965 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.837     | 99.837     | 99.837     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07672    | 0.07672    | 0.07672    |   0.0 |  0.08
Output  | 0.00020611 | 0.00020611 | 0.00020611 |   0.0 |  0.00
Modify  | 0.37554    | 0.37554    | 0.37554    |   0.0 |  0.37
Other   |            | 0.05814    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115994.0 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.621843034018, Press = 1.77320860892871
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -16026.421   -16026.421   -16100.992   -16100.992    288.59634    288.59634    36225.424    36225.424   -1715.9132   -1715.9132 
   48000     -16027.6     -16027.6   -16103.537   -16103.537    293.88467    293.88467     36204.75     36204.75   -787.06829   -787.06829 
Loop time of 104.609 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.058 hours/ns, 9.559 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.07     | 104.07     | 104.07     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07966    | 0.07966    | 0.07966    |   0.0 |  0.08
Output  | 0.00015916 | 0.00015916 | 0.00015916 |   0.0 |  0.00
Modify  | 0.39888    | 0.39888    | 0.39888    |   0.0 |  0.38
Other   |            | 0.06003    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.585618239287, Press = 1.38612175746233
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000     -16027.6     -16027.6   -16103.537   -16103.537    293.88467    293.88467     36204.75     36204.75   -787.06829   -787.06829 
   49000   -16026.173   -16026.173   -16098.771   -16098.771    280.96222    280.96222    36203.026    36203.026   -407.62568   -407.62568 
Loop time of 103.694 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.804 hours/ns, 9.644 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.17     | 103.17     | 103.17     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078032   | 0.078032   | 0.078032   |   0.0 |  0.08
Output  | 0.00018922 | 0.00018922 | 0.00018922 |   0.0 |  0.00
Modify  | 0.39075    | 0.39075    | 0.39075    |   0.0 |  0.38
Other   |            | 0.05909    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.591953534053, Press = 1.26662015761957
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -16026.173   -16026.173   -16098.771   -16098.771    280.96222    280.96222    36203.026    36203.026   -407.62568   -407.62568 
   50000    -16027.45    -16027.45   -16102.566   -16102.566    290.70763    290.70763    36217.947    36217.947   -1537.1782   -1537.1782 
Loop time of 107.169 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.806 ns/day, 29.769 hours/ns, 9.331 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.62     | 106.62     | 106.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080976   | 0.080976   | 0.080976   |   0.0 |  0.08
Output  | 0.00015699 | 0.00015699 | 0.00015699 |   0.0 |  0.00
Modify  | 0.40838    | 0.40838    | 0.40838    |   0.0 |  0.38
Other   |            | 0.06082    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115970.0 ave      115970 max      115970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115970
Ave neighs/atom = 57.985000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.620010348728, Press = 0.448727101141694
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000    -16027.45    -16027.45   -16102.566   -16102.566    290.70763    290.70763    36217.947    36217.947   -1537.1782   -1537.1782 
   51000   -16022.077   -16022.077   -16101.143   -16101.143     305.9967     305.9967    36184.793    36184.793    638.52365    638.52365 
Loop time of 106.318 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.533 hours/ns, 9.406 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.76     | 105.76     | 105.76     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08066    | 0.08066    | 0.08066    |   0.0 |  0.08
Output  | 0.00015448 | 0.00015448 | 0.00015448 |   0.0 |  0.00
Modify  | 0.41271    | 0.41271    | 0.41271    |   0.0 |  0.39
Other   |            | 0.06183    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.64240646133, Press = 0.618768095351937
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -16022.077   -16022.077   -16101.143   -16101.143     305.9967     305.9967    36184.793    36184.793    638.52365    638.52365 
   52000   -16027.473   -16027.473   -16104.017   -16104.017    296.23267    296.23267    36204.173    36204.173   -866.70351   -866.70351 
Loop time of 103.194 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.665 hours/ns, 9.691 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    | 102.66     | 102.66     | 102.66     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078756   | 0.078756   | 0.078756   |   0.0 |  0.08
Output  | 0.00018305 | 0.00018305 | 0.00018305 |   0.0 |  0.00
Modify  | 0.39192    | 0.39192    | 0.39192    |   0.0 |  0.38
Other   |            | 0.05957    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.679686802354, Press = 0.928501737877839
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -16027.473   -16027.473   -16104.017   -16104.017    296.23267    296.23267    36204.173    36204.173   -866.70351   -866.70351 
   53000   -16023.759   -16023.759   -16100.878   -16100.878    298.46134    298.46134    36165.539    36165.539    1567.9999    1567.9999 
Loop time of 96.3161 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.754 hours/ns, 10.382 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    | 95.828     | 95.828     | 95.828     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074381   | 0.074381   | 0.074381   |   0.0 |  0.08
Output  | 0.00019144 | 0.00019144 | 0.00019144 |   0.0 |  0.00
Modify  | 0.35681    | 0.35681    | 0.35681    |   0.0 |  0.37
Other   |            | 0.05638    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115994.0 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.734470598217, Press = 1.31764337446649
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -16023.759   -16023.759   -16100.878   -16100.878    298.46134    298.46134    36165.539    36165.539    1567.9999    1567.9999 
   54000   -16031.235   -16031.235   -16105.136   -16105.136    286.00631    286.00631    36144.517    36144.517    2057.7029    2057.7029 
Loop time of 106.347 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.541 hours/ns, 9.403 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.8      | 105.8      | 105.8      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080817   | 0.080817   | 0.080817   |   0.0 |  0.08
Output  | 0.00015396 | 0.00015396 | 0.00015396 |   0.0 |  0.00
Modify  | 0.41019    | 0.41019    | 0.41019    |   0.0 |  0.39
Other   |            | 0.06069    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.715801312768, Press = 1.2417120997179
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -16031.235   -16031.235   -16105.136   -16105.136    286.00631    286.00631    36144.517    36144.517    2057.7029    2057.7029 
   55000   -16025.026   -16025.026   -16101.672   -16101.672    296.62939    296.62939    36136.716    36136.716    2953.6299    2953.6299 
Loop time of 102.732 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.841 ns/day, 28.537 hours/ns, 9.734 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.2      | 102.2      | 102.2      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078744   | 0.078744   | 0.078744   |   0.0 |  0.08
Output  | 0.00018589 | 0.00018589 | 0.00018589 |   0.0 |  0.00
Modify  | 0.38961    | 0.38961    | 0.38961    |   0.0 |  0.38
Other   |            | 0.05912    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115992.0 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.706739167258, Press = 1.50716998878382
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -16025.026   -16025.026   -16101.672   -16101.672    296.62939    296.62939    36136.716    36136.716    2953.6299    2953.6299 
   56000   -16025.777   -16025.777   -16103.084   -16103.084    299.18778    299.18778    36172.613    36172.613    972.18176    972.18176 
Loop time of 105.478 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.300 hours/ns, 9.481 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.93     | 104.93     | 104.93     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081155   | 0.081155   | 0.081155   |   0.0 |  0.08
Output  | 0.00015821 | 0.00015821 | 0.00015821 |   0.0 |  0.00
Modify  | 0.40493    | 0.40493    | 0.40493    |   0.0 |  0.38
Other   |            | 0.05941    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.700344600978, Press = 0.831833492142749
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -16025.777   -16025.777   -16103.084   -16103.084    299.18778    299.18778    36172.613    36172.613    972.18176    972.18176 
   57000   -16026.286   -16026.286   -16102.773   -16102.773    296.01482    296.01482    36165.594    36165.594    1401.9767    1401.9767 
Loop time of 104.264 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.962 hours/ns, 9.591 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.73     | 103.73     | 103.73     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079238   | 0.079238   | 0.079238   |   0.0 |  0.08
Output  | 0.00015874 | 0.00015874 | 0.00015874 |   0.0 |  0.00
Modify  | 0.39493    | 0.39493    | 0.39493    |   0.0 |  0.38
Other   |            | 0.05945    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.682038325439, Press = 0.288514822738785
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -16026.286   -16026.286   -16102.773   -16102.773    296.01482    296.01482    36165.594    36165.594    1401.9767    1401.9767 
   58000   -16027.413   -16027.413       -16102       -16102    288.65909    288.65909    36179.268    36179.268    581.03577    581.03577 
Loop time of 104.367 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.991 hours/ns, 9.582 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.83     | 103.83     | 103.83     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079309   | 0.079309   | 0.079309   |   0.0 |  0.08
Output  | 0.00024315 | 0.00024315 | 0.00024315 |   0.0 |  0.00
Modify  | 0.39954    | 0.39954    | 0.39954    |   0.0 |  0.38
Other   |            | 0.06012    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.712797216232, Press = 1.01093063869525
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -16027.413   -16027.413       -16102       -16102    288.65909    288.65909    36179.268    36179.268    581.03577    581.03577 
   59000    -16021.77    -16021.77   -16099.788   -16099.788    301.93642    301.93642    36200.599    36200.599   -219.23454   -219.23454 
Loop time of 103.791 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.831 hours/ns, 9.635 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.25     | 103.25     | 103.25     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079368   | 0.079368   | 0.079368   |   0.0 |  0.08
Output  | 0.00015655 | 0.00015655 | 0.00015655 |   0.0 |  0.00
Modify  | 0.39702    | 0.39702    | 0.39702    |   0.0 |  0.38
Other   |            | 0.05955    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.746789964761, Press = 1.77705414218131
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000    -16021.77    -16021.77   -16099.788   -16099.788    301.93642    301.93642    36200.599    36200.599   -219.23454   -219.23454 
   60000   -16029.171   -16029.171   -16104.038   -16104.038    289.74432    289.74432     36200.23     36200.23   -658.20233   -658.20233 
Loop time of 106.97 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.714 hours/ns, 9.348 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.41     | 106.41     | 106.41     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081043   | 0.081043   | 0.081043   |   0.0 |  0.08
Output  | 0.00015449 | 0.00015449 | 0.00015449 |   0.0 |  0.00
Modify  | 0.41282    | 0.41282    | 0.41282    |   0.0 |  0.39
Other   |            | 0.06088    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.75385470303, Press = 2.00016545238222
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -16029.171   -16029.171   -16104.038   -16104.038    289.74432    289.74432     36200.23     36200.23   -658.20233   -658.20233 
   61000   -16027.924   -16027.924   -16101.626   -16101.626    285.23702    285.23702    36194.502    36194.502   -195.80534   -195.80534 
Loop time of 107.451 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.848 hours/ns, 9.307 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.89     | 106.89     | 106.89     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081595   | 0.081595   | 0.081595   |   0.0 |  0.08
Output  | 0.00015363 | 0.00015363 | 0.00015363 |   0.0 |  0.00
Modify  | 0.41468    | 0.41468    | 0.41468    |   0.0 |  0.39
Other   |            | 0.06061    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.785430511552, Press = 1.23942364415826
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -16027.924   -16027.924   -16101.626   -16101.626    285.23702    285.23702    36194.502    36194.502   -195.80534   -195.80534 
   62000    -16026.28    -16026.28   -16102.989   -16102.989    296.87034    296.87034    36172.504    36172.504    907.11172    907.11172 
Loop time of 101.08 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.855 ns/day, 28.078 hours/ns, 9.893 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.56     | 100.56     | 100.56     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077014   | 0.077014   | 0.077014   |   0.0 |  0.08
Output  | 0.00015448 | 0.00015448 | 0.00015448 |   0.0 |  0.00
Modify  | 0.37979    | 0.37979    | 0.37979    |   0.0 |  0.38
Other   |            | 0.05833    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.818282409046, Press = 0.590486306219247
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000    -16026.28    -16026.28   -16102.989   -16102.989    296.87034    296.87034    36172.504    36172.504    907.11172    907.11172 
   63000   -16027.552   -16027.552   -16103.082   -16103.082    292.31023    292.31023    36172.798    36172.798    990.21103    990.21103 
Loop time of 104.352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.987 hours/ns, 9.583 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.81     | 103.81     | 103.81     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079572   | 0.079572   | 0.079572   |   0.0 |  0.08
Output  | 0.00015351 | 0.00015351 | 0.00015351 |   0.0 |  0.00
Modify  | 0.39887    | 0.39887    | 0.39887    |   0.0 |  0.38
Other   |            | 0.05954    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.79942464946, Press = 0.914222806872525
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -16027.552   -16027.552   -16103.082   -16103.082    292.31023    292.31023    36172.798    36172.798    990.21103    990.21103 
   64000   -16023.524   -16023.524   -16098.601   -16098.601    290.55569    290.55569    36196.557    36196.557    51.683315    51.683315 
Loop time of 104.829 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.119 hours/ns, 9.539 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.29     | 104.29     | 104.29     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079385   | 0.079385   | 0.079385   |   0.0 |  0.08
Output  | 0.00015436 | 0.00015436 | 0.00015436 |   0.0 |  0.00
Modify  | 0.40061    | 0.40061    | 0.40061    |   0.0 |  0.38
Other   |            | 0.05955    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.830004318975, Press = -0.185389084453568
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -16023.524   -16023.524   -16098.601   -16098.601    290.55569    290.55569    36196.557    36196.557    51.683315    51.683315 
   65000     -16029.2     -16029.2   -16103.007   -16103.007    285.64245    285.64245    36163.448    36163.448    1391.1906    1391.1906 
Loop time of 99.9759 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.864 ns/day, 27.771 hours/ns, 10.002 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.467     | 99.467     | 99.467     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076449   | 0.076449   | 0.076449   |   0.0 |  0.08
Output  | 0.00019074 | 0.00019074 | 0.00019074 |   0.0 |  0.00
Modify  | 0.37474    | 0.37474    | 0.37474    |   0.0 |  0.37
Other   |            | 0.05793    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.827812233336, Press = -0.161560381513346
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000     -16029.2     -16029.2   -16103.007   -16103.007    285.64245    285.64245    36163.448    36163.448    1391.1906    1391.1906 
   66000   -16026.066   -16026.066    -16101.24    -16101.24    290.93118    290.93118    36166.894    36166.894    1373.9531    1373.9531 
Loop time of 100.825 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.857 ns/day, 28.007 hours/ns, 9.918 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.31     | 100.31     | 100.31     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078918   | 0.078918   | 0.078918   |   0.0 |  0.08
Output  | 0.00015403 | 0.00015403 | 0.00015403 |   0.0 |  0.00
Modify  | 0.38107    | 0.38107    | 0.38107    |   0.0 |  0.38
Other   |            | 0.05816    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.828079195263, Press = -0.400662611605369
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -16026.066   -16026.066    -16101.24    -16101.24    290.93118    290.93118    36166.894    36166.894    1373.9531    1373.9531 
   67000   -16027.366   -16027.366   -16102.304   -16102.304    290.02039    290.02039    36188.739    36188.739    178.05485    178.05485 
Loop time of 98.7078 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.419 hours/ns, 10.131 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.207     | 98.207     | 98.207     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075822   | 0.075822   | 0.075822   |   0.0 |  0.08
Output  | 0.0001557  | 0.0001557  | 0.0001557  |   0.0 |  0.00
Modify  | 0.36748    | 0.36748    | 0.36748    |   0.0 |  0.37
Other   |            | 0.05734    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.800523626045, Press = 0.478823140440368
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -16027.366   -16027.366   -16102.304   -16102.304    290.02039    290.02039    36188.739    36188.739    178.05485    178.05485 
   68000   -16022.268   -16022.268   -16100.763   -16100.763    303.78164    303.78164    36224.451    36224.451   -1532.6316   -1532.6316 
Loop time of 98.6301 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.397 hours/ns, 10.139 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.13      | 98.13      | 98.13      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075603   | 0.075603   | 0.075603   |   0.0 |  0.08
Output  | 0.00021761 | 0.00021761 | 0.00021761 |   0.0 |  0.00
Modify  | 0.36695    | 0.36695    | 0.36695    |   0.0 |  0.37
Other   |            | 0.05746    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.812346112131, Press = 0.260106708322604
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -16022.268   -16022.268   -16100.763   -16100.763    303.78164    303.78164    36224.451    36224.451   -1532.6316   -1532.6316 
   69000   -16028.675   -16028.675   -16104.022   -16104.022    291.59813    291.59813    36195.717    36195.717   -328.02973   -328.02973 
Loop time of 103.186 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.663 hours/ns, 9.691 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.66     | 102.66     | 102.66     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079382   | 0.079382   | 0.079382   |   0.0 |  0.08
Output  | 0.00015434 | 0.00015434 | 0.00015434 |   0.0 |  0.00
Modify  | 0.39031    | 0.39031    | 0.39031    |   0.0 |  0.38
Other   |            | 0.05925    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115992.0 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.839444481282, Press = 0.0371136287817997
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -16028.675   -16028.675   -16104.022   -16104.022    291.59813    291.59813    36195.717    36195.717   -328.02973   -328.02973 
   70000   -16024.883   -16024.883   -16103.531   -16103.531    304.37376    304.37376    36209.342    36209.342   -890.35745   -890.35745 
Loop time of 104.397 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.999 hours/ns, 9.579 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.86     | 103.86     | 103.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079486   | 0.079486   | 0.079486   |   0.0 |  0.08
Output  | 0.00021664 | 0.00021664 | 0.00021664 |   0.0 |  0.00
Modify  | 0.39812    | 0.39812    | 0.39812    |   0.0 |  0.38
Other   |            | 0.0598     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.818650147864, Press = 0.12920652064966
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -16024.883   -16024.883   -16103.531   -16103.531    304.37376    304.37376    36209.342    36209.342   -890.35745   -890.35745 
   71000   -16028.116   -16028.116    -16104.33    -16104.33    294.95796    294.95796    36221.276    36221.276   -1679.7239   -1679.7239 
Loop time of 105.819 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.394 hours/ns, 9.450 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.27     | 105.27     | 105.27     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080803   | 0.080803   | 0.080803   |   0.0 |  0.08
Output  | 0.00050863 | 0.00050863 | 0.00050863 |   0.0 |  0.00
Modify  | 0.40581    | 0.40581    | 0.40581    |   0.0 |  0.38
Other   |            | 0.06004    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.789465999782, Press = -0.112800809015765
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -16028.116   -16028.116    -16104.33    -16104.33    294.95796    294.95796    36221.276    36221.276   -1679.7239   -1679.7239 
   72000   -16026.376   -16026.376   -16101.877   -16101.877    292.19946    292.19946    36226.088    36226.088   -1757.5295   -1757.5295 
Loop time of 106.828 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.674 hours/ns, 9.361 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.27     | 106.27     | 106.27     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08079    | 0.08079    | 0.08079    |   0.0 |  0.08
Output  | 0.00015684 | 0.00015684 | 0.00015684 |   0.0 |  0.00
Modify  | 0.4126     | 0.4126     | 0.4126     |   0.0 |  0.39
Other   |            | 0.06137    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.753109459665, Press = -0.110820093114143
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -16026.376   -16026.376   -16101.877   -16101.877    292.19946    292.19946    36226.088    36226.088   -1757.5295   -1757.5295 
   73000   -16028.304   -16028.304   -16101.454   -16101.454    283.09823    283.09823    36208.213    36208.213   -875.87474   -875.87474 
Loop time of 104.948 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.152 hours/ns, 9.528 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.41     | 104.41     | 104.41     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079746   | 0.079746   | 0.079746   |   0.0 |  0.08
Output  | 0.00025919 | 0.00025919 | 0.00025919 |   0.0 |  0.00
Modify  | 0.39758    | 0.39758    | 0.39758    |   0.0 |  0.38
Other   |            | 0.0593     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.765272715273, Press = 0.401805386645164
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -16028.304   -16028.304   -16101.454   -16101.454    283.09823    283.09823    36208.213    36208.213   -875.87474   -875.87474 
   74000   -16024.564   -16024.564   -16102.753   -16102.753    302.60054    302.60054    36233.306    36233.306   -2181.0271   -2181.0271 
Loop time of 100.512 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.860 ns/day, 27.920 hours/ns, 9.949 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.996     | 99.996     | 99.996     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07712    | 0.07712    | 0.07712    |   0.0 |  0.08
Output  | 0.00015271 | 0.00015271 | 0.00015271 |   0.0 |  0.00
Modify  | 0.37931    | 0.37931    | 0.37931    |   0.0 |  0.38
Other   |            | 0.05867    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.772584628068, Press = 0.636069105252948
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -16024.564   -16024.564   -16102.753   -16102.753    302.60054    302.60054    36233.306    36233.306   -2181.0271   -2181.0271 
   75000   -16031.522   -16031.522   -16102.613   -16102.613    275.12972    275.12972    36192.524    36192.524   -182.78597   -182.78597 
Loop time of 102.346 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.430 hours/ns, 9.771 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.82     | 101.82     | 101.82     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077938   | 0.077938   | 0.077938   |   0.0 |  0.08
Output  | 0.00015361 | 0.00015361 | 0.00015361 |   0.0 |  0.00
Modify  | 0.38709    | 0.38709    | 0.38709    |   0.0 |  0.38
Other   |            | 0.05916    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.765411212022, Press = 0.554199580820613
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -16031.522   -16031.522   -16102.613   -16102.613    275.12972    275.12972    36192.524    36192.524   -182.78597   -182.78597 
   76000   -16024.457   -16024.457   -16102.015   -16102.015    300.15795    300.15795    36220.695    36220.695    -1445.007    -1445.007 
Loop time of 104.908 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.141 hours/ns, 9.532 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.37     | 104.37     | 104.37     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079457   | 0.079457   | 0.079457   |   0.0 |  0.08
Output  | 0.0001541  | 0.0001541  | 0.0001541  |   0.0 |  0.00
Modify  | 0.40109    | 0.40109    | 0.40109    |   0.0 |  0.38
Other   |            | 0.05982    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.743449358127, Press = 0.279977975540536
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -16024.457   -16024.457   -16102.015   -16102.015    300.15795    300.15795    36220.695    36220.695    -1445.007    -1445.007 
   77000   -16028.439   -16028.439     -16103.7     -16103.7    291.27095    291.27095    36214.344    36214.344   -1245.9137   -1245.9137 
Loop time of 100.084 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.863 ns/day, 27.801 hours/ns, 9.992 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.571     | 99.571     | 99.571     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076879   | 0.076879   | 0.076879   |   0.0 |  0.08
Output  | 0.00019776 | 0.00019776 | 0.00019776 |   0.0 |  0.00
Modify  | 0.37769    | 0.37769    | 0.37769    |   0.0 |  0.38
Other   |            | 0.05757    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.737438435206, Press = 0.562771120450848
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -16028.439   -16028.439     -16103.7     -16103.7    291.27095    291.27095    36214.344    36214.344   -1245.9137   -1245.9137 
   78000   -16029.844   -16029.844   -16104.854   -16104.854    290.29313    290.29313    36213.794    36213.794   -1430.8489   -1430.8489 
Loop time of 101.684 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.850 ns/day, 28.245 hours/ns, 9.834 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.16     | 101.16     | 101.16     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078016   | 0.078016   | 0.078016   |   0.0 |  0.08
Output  | 0.00015686 | 0.00015686 | 0.00015686 |   0.0 |  0.00
Modify  | 0.3886     | 0.3886     | 0.3886     |   0.0 |  0.38
Other   |            | 0.05862    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.744527739124, Press = 0.758969224762932
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -16029.844   -16029.844   -16104.854   -16104.854    290.29313    290.29313    36213.794    36213.794   -1430.8489   -1430.8489 
   79000   -16026.872   -16026.872   -16100.108   -16100.108    283.42995    283.42995    36197.809    36197.809   -214.37384   -214.37384 
Loop time of 101.246 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.853 ns/day, 28.124 hours/ns, 9.877 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.73     | 100.73     | 100.73     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07813    | 0.07813    | 0.07813    |   0.0 |  0.08
Output  | 0.00018813 | 0.00018813 | 0.00018813 |   0.0 |  0.00
Modify  | 0.38329    | 0.38329    | 0.38329    |   0.0 |  0.38
Other   |            | 0.05877    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.714923187889, Press = 0.632110985664388
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -16026.872   -16026.872   -16100.108   -16100.108    283.42995    283.42995    36197.809    36197.809   -214.37384   -214.37384 
   80000   -16029.868   -16029.868   -16106.677   -16106.677    297.25703    297.25703     36237.18     36237.18   -2785.6795   -2785.6795 
Loop time of 108.677 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.795 ns/day, 30.188 hours/ns, 9.202 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.11     | 108.11     | 108.11     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082941   | 0.082941   | 0.082941   |   0.0 |  0.08
Output  | 0.0001947  | 0.0001947  | 0.0001947  |   0.0 |  0.00
Modify  | 0.42249    | 0.42249    | 0.42249    |   0.0 |  0.39
Other   |            | 0.06156    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.718549183915, Press = 1.03369462288281
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -16029.868   -16029.868   -16106.677   -16106.677    297.25703    297.25703     36237.18     36237.18   -2785.6795   -2785.6795 
   81000   -16025.348   -16025.348   -16102.746   -16102.746    299.53743    299.53743    36205.908    36205.908   -723.17481   -723.17481 
Loop time of 101.888 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.848 ns/day, 28.302 hours/ns, 9.815 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.37     | 101.37     | 101.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077071   | 0.077071   | 0.077071   |   0.0 |  0.08
Output  | 0.00015171 | 0.00015171 | 0.00015171 |   0.0 |  0.00
Modify  | 0.38301    | 0.38301    | 0.38301    |   0.0 |  0.38
Other   |            | 0.05872    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.702887470479, Press = 0.786572465123943
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -16025.348   -16025.348   -16102.746   -16102.746    299.53743    299.53743    36205.908    36205.908   -723.17481   -723.17481 
   82000   -16029.895   -16029.895   -16103.665   -16103.665    285.49776    285.49776    36204.468    36204.468   -841.54423   -841.54423 
Loop time of 99.1409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.539 hours/ns, 10.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    | 98.637     | 98.637     | 98.637     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076407   | 0.076407   | 0.076407   |   0.0 |  0.08
Output  | 0.00019077 | 0.00019077 | 0.00019077 |   0.0 |  0.00
Modify  | 0.37088    | 0.37088    | 0.37088    |   0.0 |  0.37
Other   |            | 0.05675    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.694963679493, Press = 0.857474967442451
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -16029.895   -16029.895   -16103.665   -16103.665    285.49776    285.49776    36204.468    36204.468   -841.54423   -841.54423 
   83000   -16025.285   -16025.285   -16102.298   -16102.298    298.04933    298.04933    36208.879    36208.879   -854.92185   -854.92185 
Loop time of 100.621 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.859 ns/day, 27.950 hours/ns, 9.938 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.11     | 100.11     | 100.11     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076316   | 0.076316   | 0.076316   |   0.0 |  0.08
Output  | 0.00015516 | 0.00015516 | 0.00015516 |   0.0 |  0.00
Modify  | 0.37631    | 0.37631    | 0.37631    |   0.0 |  0.37
Other   |            | 0.05807    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.676777128895, Press = 0.713439301744321
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -16025.285   -16025.285   -16102.298   -16102.298    298.04933    298.04933    36208.879    36208.879   -854.92185   -854.92185 
   84000   -16029.026   -16029.026   -16101.782   -16101.782    281.57583    281.57583    36212.351    36212.351   -1159.1591   -1159.1591 
Loop time of 102.283 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.412 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.76     | 101.76     | 101.76     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078849   | 0.078849   | 0.078849   |   0.0 |  0.08
Output  | 0.00015534 | 0.00015534 | 0.00015534 |   0.0 |  0.00
Modify  | 0.38628    | 0.38628    | 0.38628    |   0.0 |  0.38
Other   |            | 0.05874    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.667349920796, Press = 0.699136827885817
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -16029.026   -16029.026   -16101.782   -16101.782    281.57583    281.57583    36212.351    36212.351   -1159.1591   -1159.1591 
   85000   -16025.532   -16025.532   -16102.402   -16102.402    297.49585    297.49585    36205.574    36205.574   -635.36064   -635.36064 
Loop time of 96.85 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.903 hours/ns, 10.325 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    | 96.361     | 96.361     | 96.361     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074041   | 0.074041   | 0.074041   |   0.0 |  0.08
Output  | 0.00015785 | 0.00015785 | 0.00015785 |   0.0 |  0.00
Modify  | 0.35803    | 0.35803    | 0.35803    |   0.0 |  0.37
Other   |            | 0.05632    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.703307411705, Press = 0.692831872039521
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -16025.532   -16025.532   -16102.402   -16102.402    297.49585    297.49585    36205.574    36205.574   -635.36064   -635.36064 
   86000   -16027.567   -16027.567   -16101.579   -16101.579    286.43546    286.43546    36198.991    36198.991   -336.75923   -336.75923 
Loop time of 102.07 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.846 ns/day, 28.353 hours/ns, 9.797 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.54     | 101.54     | 101.54     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078072   | 0.078072   | 0.078072   |   0.0 |  0.08
Output  | 0.00015544 | 0.00015544 | 0.00015544 |   0.0 |  0.00
Modify  | 0.39006    | 0.39006    | 0.39006    |   0.0 |  0.38
Other   |            | 0.05953    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.703879413027, Press = 0.856972434307385
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -16027.567   -16027.567   -16101.579   -16101.579    286.43546    286.43546    36198.991    36198.991   -336.75923   -336.75923 
   87000   -16027.801   -16027.801   -16104.874   -16104.874    298.27958    298.27958    36219.771    36219.771   -1679.9357   -1679.9357 
Loop time of 100.694 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.858 ns/day, 27.971 hours/ns, 9.931 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.18     | 100.18     | 100.18     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076658   | 0.076658   | 0.076658   |   0.0 |  0.08
Output  | 0.00018496 | 0.00018496 | 0.00018496 |   0.0 |  0.00
Modify  | 0.37849    | 0.37849    | 0.37849    |   0.0 |  0.38
Other   |            | 0.0591     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.679972622589, Press = 1.15810608968126
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -16027.801   -16027.801   -16104.874   -16104.874    298.27958    298.27958    36219.771    36219.771   -1679.9357   -1679.9357 
   88000   -16026.411   -16026.411   -16101.976   -16101.976    292.44676    292.44676     36189.32     36189.32    143.02247    143.02247 
Loop time of 103.811 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.837 hours/ns, 9.633 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.28     | 103.28     | 103.28     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078685   | 0.078685   | 0.078685   |   0.0 |  0.08
Output  | 0.00015647 | 0.00015647 | 0.00015647 |   0.0 |  0.00
Modify  | 0.39338    | 0.39338    | 0.39338    |   0.0 |  0.38
Other   |            | 0.05921    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.692611852068, Press = 0.720867459471322
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -16026.411   -16026.411   -16101.976   -16101.976    292.44676    292.44676     36189.32     36189.32    143.02247    143.02247 
   89000   -16024.727   -16024.727   -16103.546   -16103.546    305.03644    305.03644    36187.865    36187.865    233.01726    233.01726 
Loop time of 102.354 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.432 hours/ns, 9.770 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.83     | 101.83     | 101.83     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078454   | 0.078454   | 0.078454   |   0.0 |  0.08
Output  | 0.00015171 | 0.00015171 | 0.00015171 |   0.0 |  0.00
Modify  | 0.38872    | 0.38872    | 0.38872    |   0.0 |  0.38
Other   |            | 0.05967    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.695059838425, Press = 0.526213042120304
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -16024.727   -16024.727   -16103.546   -16103.546    305.03644    305.03644    36187.865    36187.865    233.01726    233.01726 
   90000   -16024.629   -16024.629   -16101.277   -16101.277      296.637      296.637    36227.307    36227.307   -1734.1355   -1734.1355 
Loop time of 105.932 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.425 hours/ns, 9.440 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.38     | 105.38     | 105.38     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081213   | 0.081213   | 0.081213   |   0.0 |  0.08
Output  | 0.00015438 | 0.00015438 | 0.00015438 |   0.0 |  0.00
Modify  | 0.408      | 0.408      | 0.408      |   0.0 |  0.39
Other   |            | 0.06073    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.715284871472, Press = 0.35755388702685
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -16024.629   -16024.629   -16101.277   -16101.277      296.637      296.637    36227.307    36227.307   -1734.1355   -1734.1355 
   91000   -16025.907   -16025.907   -16101.929   -16101.929    294.21419    294.21419    36216.469    36216.469   -1286.9879   -1286.9879 
Loop time of 99.376 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.604 hours/ns, 10.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    | 98.874     | 98.874     | 98.874     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075568   | 0.075568   | 0.075568   |   0.0 |  0.08
Output  | 0.00015385 | 0.00015385 | 0.00015385 |   0.0 |  0.00
Modify  | 0.36821    | 0.36821    | 0.36821    |   0.0 |  0.37
Other   |            | 0.05792    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.72642770412, Press = 0.371649916027687
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -16025.907   -16025.907   -16101.929   -16101.929    294.21419    294.21419    36216.469    36216.469   -1286.9879   -1286.9879 
   92000   -16028.129   -16028.129   -16101.832   -16101.832    285.23891    285.23891    36233.301    36233.301   -2249.1694   -2249.1694 
Loop time of 100.243 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.862 ns/day, 27.845 hours/ns, 9.976 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.734     | 99.734     | 99.734     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076262   | 0.076262   | 0.076262   |   0.0 |  0.08
Output  | 0.00020804 | 0.00020804 | 0.00020804 |   0.0 |  0.00
Modify  | 0.37565    | 0.37565    | 0.37565    |   0.0 |  0.37
Other   |            | 0.0576     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.735926021558, Press = 0.108864491876787
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -16028.129   -16028.129   -16101.832   -16101.832    285.23891    285.23891    36233.301    36233.301   -2249.1694   -2249.1694 
   93000   -16025.521   -16025.521   -16102.165   -16102.165    296.61809    296.61809    36219.001    36219.001   -1372.6105   -1372.6105 
Loop time of 100.975 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.856 ns/day, 28.049 hours/ns, 9.903 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.46     | 100.46     | 100.46     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076259   | 0.076259   | 0.076259   |   0.0 |  0.08
Output  | 0.00015496 | 0.00015496 | 0.00015496 |   0.0 |  0.00
Modify  | 0.37712    | 0.37712    | 0.37712    |   0.0 |  0.37
Other   |            | 0.05824    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.760117242878, Press = -0.100901398206432
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -16025.521   -16025.521   -16102.165   -16102.165    296.61809    296.61809    36219.001    36219.001   -1372.6105   -1372.6105 
   94000   -16026.787   -16026.787   -16101.979   -16101.979    291.00117    291.00117    36211.868    36211.868    -1053.884    -1053.884 
Loop time of 97.466 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.886 ns/day, 27.074 hours/ns, 10.260 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    | 96.975     | 96.975     | 96.975     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074016   | 0.074016   | 0.074016   |   0.0 |  0.08
Output  | 0.000157   | 0.000157   | 0.000157   |   0.0 |  0.00
Modify  | 0.3599     | 0.3599     | 0.3599     |   0.0 |  0.37
Other   |            | 0.05716    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.745458494288, Press = 0.244758578464107
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -16026.787   -16026.787   -16101.979   -16101.979    291.00117    291.00117    36211.868    36211.868    -1053.884    -1053.884 
   95000   -16027.767   -16027.767   -16104.041   -16104.041    295.18885    295.18885    36239.605    36239.605   -2630.9071   -2630.9071 
Loop time of 99.0841 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.523 hours/ns, 10.092 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    | 98.58      | 98.58      | 98.58      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076158   | 0.076158   | 0.076158   |   0.0 |  0.08
Output  | 0.00015343 | 0.00015343 | 0.00015343 |   0.0 |  0.00
Modify  | 0.37033    | 0.37033    | 0.37033    |   0.0 |  0.37
Other   |            | 0.05778    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.767491817728, Press = 0.0416660680861684
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -16027.767   -16027.767   -16104.041   -16104.041    295.18885    295.18885    36239.605    36239.605   -2630.9071   -2630.9071 
   96000     -16026.2     -16026.2   -16101.634   -16101.634    291.93709    291.93709    36222.506    36222.506   -1484.1551   -1484.1551 
Loop time of 106.565 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.601 hours/ns, 9.384 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.01     | 106.01     | 106.01     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080829   | 0.080829   | 0.080829   |   0.0 |  0.08
Output  | 0.00015454 | 0.00015454 | 0.00015454 |   0.0 |  0.00
Modify  | 0.41155    | 0.41155    | 0.41155    |   0.0 |  0.39
Other   |            | 0.06121    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.765033612107, Press = -0.0632751838738813
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000     -16026.2     -16026.2   -16101.634   -16101.634    291.93709    291.93709    36222.506    36222.506   -1484.1551   -1484.1551 
   97000   -16029.563   -16029.563    -16106.78    -16106.78    298.83693    298.83693    36220.552    36220.552   -1806.1089   -1806.1089 
Loop time of 97.4153 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.060 hours/ns, 10.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    | 96.922     | 96.922     | 96.922     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074288   | 0.074288   | 0.074288   |   0.0 |  0.08
Output  | 0.00015578 | 0.00015578 | 0.00015578 |   0.0 |  0.00
Modify  | 0.36207    | 0.36207    | 0.36207    |   0.0 |  0.37
Other   |            | 0.0572     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.744742550639, Press = 0.0129049229920795
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -16029.563   -16029.563    -16106.78    -16106.78    298.83693    298.83693    36220.552    36220.552   -1806.1089   -1806.1089 
   98000    -16022.15    -16022.15   -16100.684   -16100.684    303.93685    303.93685    36208.126    36208.126   -627.56078   -627.56078 
Loop time of 101.263 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.853 ns/day, 28.129 hours/ns, 9.875 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.75     | 100.75     | 100.75     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077175   | 0.077175   | 0.077175   |   0.0 |  0.08
Output  | 0.00015546 | 0.00015546 | 0.00015546 |   0.0 |  0.00
Modify  | 0.37887    | 0.37887    | 0.37887    |   0.0 |  0.37
Other   |            | 0.05809    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.774724278707, Press = 0.0428075633613093
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000    -16022.15    -16022.15   -16100.684   -16100.684    303.93685    303.93685    36208.126    36208.126   -627.56078   -627.56078 
   99000   -16025.888   -16025.888    -16103.64    -16103.64    300.90678    300.90678    36199.583    36199.583   -449.84441   -449.84441 
Loop time of 97.7868 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.163 hours/ns, 10.226 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.293     | 97.293     | 97.293     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073611   | 0.073611   | 0.073611   |   0.0 |  0.08
Output  | 0.000183   | 0.000183   | 0.000183   |   0.0 |  0.00
Modify  | 0.36312    | 0.36312    | 0.36312    |   0.0 |  0.37
Other   |            | 0.05721    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.790217478082, Press = 0.189336682129534
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -16025.888   -16025.888    -16103.64    -16103.64    300.90678    300.90678    36199.583    36199.583   -449.84441   -449.84441 
  100000   -16026.133   -16026.133   -16102.424   -16102.424    295.25081    295.25081    36159.521    36159.521    1760.0894    1760.0894 
Loop time of 105.445 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.290 hours/ns, 9.484 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.9      | 104.9      | 104.9      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079565   | 0.079565   | 0.079565   |   0.0 |  0.08
Output  | 0.00015487 | 0.00015487 | 0.00015487 |   0.0 |  0.00
Modify  | 0.40278    | 0.40278    | 0.40278    |   0.0 |  0.38
Other   |            | 0.06108    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.797311116636, Press = 0.246106400951164
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -16026.133   -16026.133   -16102.424   -16102.424    295.25081    295.25081    36159.521    36159.521    1760.0894    1760.0894 
  101000   -16027.975   -16027.975   -16105.196   -16105.196    298.85463    298.85463    36176.978    36176.978    536.97246    536.97246 
Loop time of 103.336 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.704 hours/ns, 9.677 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.81     | 102.81     | 102.81     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077484   | 0.077484   | 0.077484   |   0.0 |  0.07
Output  | 0.00015395 | 0.00015395 | 0.00015395 |   0.0 |  0.00
Modify  | 0.39117    | 0.39117    | 0.39117    |   0.0 |  0.38
Other   |            | 0.05888    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.778739500282, Press = 0.111372607850006
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -16027.975   -16027.975   -16105.196   -16105.196    298.85463    298.85463    36176.978    36176.978    536.97246    536.97246 
  102000    -16024.08    -16024.08   -16102.208   -16102.208    302.36295    302.36295    36151.087    36151.087    2245.5458    2245.5458 
Loop time of 99.5637 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.657 hours/ns, 10.044 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.061     | 99.061     | 99.061     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075763   | 0.075763   | 0.075763   |   0.0 |  0.08
Output  | 0.00024939 | 0.00024939 | 0.00024939 |   0.0 |  0.00
Modify  | 0.36928    | 0.36928    | 0.36928    |   0.0 |  0.37
Other   |            | 0.05785    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115992.0 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.811947810333, Press = -0.178078558840077
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000    -16024.08    -16024.08   -16102.208   -16102.208    302.36295    302.36295    36151.087    36151.087    2245.5458    2245.5458 
  103000   -16026.592   -16026.592   -16103.013   -16103.013    295.75589    295.75589     36162.48     36162.48    1511.4782    1511.4782 
Loop time of 101.628 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.850 ns/day, 28.230 hours/ns, 9.840 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.11     | 101.11     | 101.11     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077737   | 0.077737   | 0.077737   |   0.0 |  0.08
Output  | 0.00015397 | 0.00015397 | 0.00015397 |   0.0 |  0.00
Modify  | 0.38425    | 0.38425    | 0.38425    |   0.0 |  0.38
Other   |            | 0.05906    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.803723140896, Press = 0.182132692227334
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000   -16026.592   -16026.592   -16103.013   -16103.013    295.75589    295.75589     36162.48     36162.48    1511.4782    1511.4782 
  104000   -16028.929   -16028.929   -16103.056   -16103.056    286.87691    286.87691    36161.723    36161.723    1507.5804    1507.5804 
Loop time of 102.264 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.407 hours/ns, 9.779 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.74     | 101.74     | 101.74     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077108   | 0.077108   | 0.077108   |   0.0 |  0.08
Output  | 0.00015533 | 0.00015533 | 0.00015533 |   0.0 |  0.00
Modify  | 0.39007    | 0.39007    | 0.39007    |   0.0 |  0.38
Other   |            | 0.05987    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.801685147824, Press = 0.397211280604023
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  104000   -16028.929   -16028.929   -16103.056   -16103.056    286.87691    286.87691    36161.723    36161.723    1507.5804    1507.5804 
  105000   -16023.663   -16023.663   -16100.785   -16100.785    298.46636    298.46636    36184.983    36184.983    509.15203    509.15203 
Loop time of 104.193 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.942 hours/ns, 9.598 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.66     | 103.66     | 103.66     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078407   | 0.078407   | 0.078407   |   0.0 |  0.08
Output  | 0.00018557 | 0.00018557 | 0.00018557 |   0.0 |  0.00
Modify  | 0.39871    | 0.39871    | 0.39871    |   0.0 |  0.38
Other   |            | 0.0604     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115992.0 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.808996138128, Press = 0.310640415787444
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  105000   -16023.663   -16023.663   -16100.785   -16100.785    298.46636    298.46636    36184.983    36184.983    509.15203    509.15203 
  106000   -16028.067   -16028.067   -16103.266   -16103.266    291.02827    291.02827    36131.878    36131.878    3090.3062    3090.3062 
Loop time of 101.617 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.850 ns/day, 28.227 hours/ns, 9.841 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.1      | 101.1      | 101.1      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076597   | 0.076597   | 0.076597   |   0.0 |  0.08
Output  | 0.00015289 | 0.00015289 | 0.00015289 |   0.0 |  0.00
Modify  | 0.38098    | 0.38098    | 0.38098    |   0.0 |  0.37
Other   |            | 0.0589     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.81677796535, Press = 0.467470534947377
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  106000   -16028.067   -16028.067   -16103.266   -16103.266    291.02827    291.02827    36131.878    36131.878    3090.3062    3090.3062 
  107000   -16025.136   -16025.136   -16102.683   -16102.683    300.11512    300.11512     36119.99     36119.99    3776.4291    3776.4291 
Loop time of 97.7537 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.154 hours/ns, 10.230 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.259     | 97.259     | 97.259     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074563   | 0.074563   | 0.074563   |   0.0 |  0.08
Output  | 0.00015541 | 0.00015541 | 0.00015541 |   0.0 |  0.00
Modify  | 0.36288    | 0.36288    | 0.36288    |   0.0 |  0.37
Other   |            | 0.0568     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.824459152911, Press = 0.606710284194773
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  107000   -16025.136   -16025.136   -16102.683   -16102.683    300.11512    300.11512     36119.99     36119.99    3776.4291    3776.4291 
  108000   -16025.373   -16025.373   -16102.228   -16102.228    297.43629    297.43629    36145.774    36145.774     2537.002     2537.002 
Loop time of 99.572 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.659 hours/ns, 10.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    | 99.069     | 99.069     | 99.069     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074632   | 0.074632   | 0.074632   |   0.0 |  0.07
Output  | 0.00021773 | 0.00021773 | 0.00021773 |   0.0 |  0.00
Modify  | 0.37032    | 0.37032    | 0.37032    |   0.0 |  0.37
Other   |            | 0.05772    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.820768885113, Press = 0.385871316122247
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  108000   -16025.373   -16025.373   -16102.228   -16102.228    297.43629    297.43629    36145.774    36145.774     2537.002     2537.002 
  109000   -16029.034   -16029.034   -16103.188   -16103.188     286.9832     286.9832    36158.194    36158.194    1652.8591    1652.8591 
Loop time of 101.352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.852 ns/day, 28.153 hours/ns, 9.867 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.84     | 100.84     | 100.84     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07633    | 0.07633    | 0.07633    |   0.0 |  0.08
Output  | 0.00015537 | 0.00015537 | 0.00015537 |   0.0 |  0.00
Modify  | 0.38138    | 0.38138    | 0.38138    |   0.0 |  0.38
Other   |            | 0.05845    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.829551741382, Press = 0.404942806650761
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  109000   -16029.034   -16029.034   -16103.188   -16103.188     286.9832     286.9832    36158.194    36158.194    1652.8591    1652.8591 
  110000   -16026.744   -16026.744   -16102.286   -16102.286    292.35465    292.35465    36189.406    36189.406    78.202507    78.202507 
Loop time of 102.606 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.842 ns/day, 28.502 hours/ns, 9.746 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.08     | 102.08     | 102.08     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076451   | 0.076451   | 0.076451   |   0.0 |  0.07
Output  | 0.00015384 | 0.00015384 | 0.00015384 |   0.0 |  0.00
Modify  | 0.38672    | 0.38672    | 0.38672    |   0.0 |  0.38
Other   |            | 0.05944    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.833929369487, Press = 0.545888584593618
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  110000   -16026.744   -16026.744   -16102.286   -16102.286    292.35465    292.35465    36189.406    36189.406    78.202507    78.202507 
  111000   -16031.102   -16031.102   -16103.243   -16103.243    279.19318    279.19318    36183.975    36183.975     306.4508     306.4508 
Loop time of 99.1226 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.534 hours/ns, 10.089 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.618     | 98.618     | 98.618     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075909   | 0.075909   | 0.075909   |   0.0 |  0.08
Output  | 0.00021501 | 0.00021501 | 0.00021501 |   0.0 |  0.00
Modify  | 0.37013    | 0.37013    | 0.37013    |   0.0 |  0.37
Other   |            | 0.05862    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.821378829067, Press = 0.693561810777247
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  111000   -16031.102   -16031.102   -16103.243   -16103.243    279.19318    279.19318    36183.975    36183.975     306.4508     306.4508 
  112000   -16027.771   -16027.771   -16102.711   -16102.711    290.02507    290.02507    36225.535    36225.535   -1892.6355   -1892.6355 
Loop time of 102.501 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.473 hours/ns, 9.756 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.98     | 101.98     | 101.98     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077644   | 0.077644   | 0.077644   |   0.0 |  0.08
Output  | 0.00046344 | 0.00046344 | 0.00046344 |   0.0 |  0.00
Modify  | 0.38573    | 0.38573    | 0.38573    |   0.0 |  0.38
Other   |            | 0.05967    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.790323102494, Press = 1.02255083514972
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  112000   -16027.771   -16027.771   -16102.711   -16102.711    290.02507    290.02507    36225.535    36225.535   -1892.6355   -1892.6355 
  113000   -16028.225   -16028.225   -16103.761   -16103.761    292.33282    292.33282    36188.046    36188.046    98.606332    98.606332 
Loop time of 104.401 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 29.000 hours/ns, 9.578 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.86     | 103.86     | 103.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078101   | 0.078101   | 0.078101   |   0.0 |  0.07
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.39792    | 0.39792    | 0.39792    |   0.0 |  0.38
Other   |            | 0.06027    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.793135242708, Press = 0.47240911307727
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  113000   -16028.225   -16028.225   -16103.761   -16103.761    292.33282    292.33282    36188.046    36188.046    98.606332    98.606332 
  114000    -16021.03    -16021.03   -16101.559   -16101.559    311.65415    311.65415    36198.786    36198.786   -249.40831   -249.40831 
Loop time of 103.349 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.708 hours/ns, 9.676 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.82     | 102.82     | 102.82     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078949   | 0.078949   | 0.078949   |   0.0 |  0.08
Output  | 0.00015593 | 0.00015593 | 0.00015593 |   0.0 |  0.00
Modify  | 0.39408    | 0.39408    | 0.39408    |   0.0 |  0.38
Other   |            | 0.06002    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.811559337184, Press = 0.577004490987413
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  114000    -16021.03    -16021.03   -16101.559   -16101.559    311.65415    311.65415    36198.786    36198.786   -249.40831   -249.40831 
  115000   -16029.075   -16029.075   -16102.505   -16102.505    284.18207    284.18207    36171.467    36171.467    962.27773    962.27773 
Loop time of 106.456 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.571 hours/ns, 9.394 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.91     | 105.91     | 105.91     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079809   | 0.079809   | 0.079809   |   0.0 |  0.07
Output  | 0.00015396 | 0.00015396 | 0.00015396 |   0.0 |  0.00
Modify  | 0.40992    | 0.40992    | 0.40992    |   0.0 |  0.39
Other   |            | 0.06107    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.830807204269, Press = 0.494923416770716
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  115000   -16029.075   -16029.075   -16102.505   -16102.505    284.18207    284.18207    36171.467    36171.467    962.27773    962.27773 
  116000   -16026.793   -16026.793    -16101.88    -16101.88    290.59133    290.59133    36177.727    36177.727    731.88119    731.88119 
Loop time of 98.0842 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.246 hours/ns, 10.195 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    | 97.587     | 97.587     | 97.587     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074737   | 0.074737   | 0.074737   |   0.0 |  0.08
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.36535    | 0.36535    | 0.36535    |   0.0 |  0.37
Other   |            | 0.05717    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.833888626346, Press = 0.403739761871407
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  116000   -16026.793   -16026.793    -16101.88    -16101.88    290.59133    290.59133    36177.727    36177.727    731.88119    731.88119 
  117000   -16026.983   -16026.983   -16104.626   -16104.626     300.4896     300.4896    36156.177    36156.177    1685.2328    1685.2328 
Loop time of 100.663 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.858 ns/day, 27.962 hours/ns, 9.934 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.15     | 100.15     | 100.15     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076012   | 0.076012   | 0.076012   |   0.0 |  0.08
Output  | 0.00015666 | 0.00015666 | 0.00015666 |   0.0 |  0.00
Modify  | 0.37657    | 0.37657    | 0.37657    |   0.0 |  0.37
Other   |            | 0.05782    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115972.0 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.832756432778, Press = 0.275936598942894
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  117000   -16026.983   -16026.983   -16104.626   -16104.626     300.4896     300.4896    36156.177    36156.177    1685.2328    1685.2328 
  118000   -16027.373   -16027.373   -16102.665   -16102.665    291.38622    291.38622    36126.681    36126.681    3364.1238    3364.1238 
Loop time of 101.155 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.854 ns/day, 28.099 hours/ns, 9.886 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.64     | 100.64     | 100.64     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076576   | 0.076576   | 0.076576   |   0.0 |  0.08
Output  | 0.000217   | 0.000217   | 0.000217   |   0.0 |  0.00
Modify  | 0.38255    | 0.38255    | 0.38255    |   0.0 |  0.38
Other   |            | 0.05889    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.852395011595, Press = 0.547014233941494
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  118000   -16027.373   -16027.373   -16102.665   -16102.665    291.38622    291.38622    36126.681    36126.681    3364.1238    3364.1238 
  119000   -16023.723   -16023.723   -16100.141   -16100.141    295.74577    295.74577    36166.339    36166.339    1498.8485    1498.8485 
Loop time of 107.518 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.866 hours/ns, 9.301 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.96     | 106.96     | 106.96     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081117   | 0.081117   | 0.081117   |   0.0 |  0.08
Output  | 0.00019271 | 0.00019271 | 0.00019271 |   0.0 |  0.00
Modify  | 0.41261    | 0.41261    | 0.41261    |   0.0 |  0.38
Other   |            | 0.06061    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.851177132539, Press = 0.424838694421307
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  119000   -16023.723   -16023.723   -16100.141   -16100.141    295.74577    295.74577    36166.339    36166.339    1498.8485    1498.8485 
  120000   -16029.486   -16029.486   -16103.646   -16103.646    287.00482    287.00482    36190.448    36190.448   -181.49233   -181.49233 
Loop time of 104.279 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.966 hours/ns, 9.590 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.74     | 103.74     | 103.74     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078823   | 0.078823   | 0.078823   |   0.0 |  0.08
Output  | 0.00015706 | 0.00015706 | 0.00015706 |   0.0 |  0.00
Modify  | 0.39837    | 0.39837    | 0.39837    |   0.0 |  0.38
Other   |            | 0.05972    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115992.0 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.855954432959, Press = 0.43131742400893
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  120000   -16029.486   -16029.486   -16103.646   -16103.646    287.00482    287.00482    36190.448    36190.448   -181.49233   -181.49233 
  121000   -16025.464   -16025.464   -16101.051   -16101.051    292.53003    292.53003    36166.538    36166.538    1499.8581    1499.8581 
Loop time of 103.138 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.650 hours/ns, 9.696 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    | 102.61     | 102.61     | 102.61     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077827   | 0.077827   | 0.077827   |   0.0 |  0.08
Output  | 0.00015534 | 0.00015534 | 0.00015534 |   0.0 |  0.00
Modify  | 0.39105    | 0.39105    | 0.39105    |   0.0 |  0.38
Other   |            | 0.0595     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.85564572533, Press = 0.587218563441225
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  121000   -16025.464   -16025.464   -16101.051   -16101.051    292.53003    292.53003    36166.538    36166.538    1499.8581    1499.8581 
  122000   -16027.339   -16027.339   -16104.033   -16104.033    296.81333    296.81333    36160.881    36160.881    1521.6939    1521.6939 
Loop time of 100.911 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.856 ns/day, 28.031 hours/ns, 9.910 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.39     | 100.39     | 100.39     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076378   | 0.076378   | 0.076378   |   0.0 |  0.08
Output  | 0.00026083 | 0.00026083 | 0.00026083 |   0.0 |  0.00
Modify  | 0.38208    | 0.38208    | 0.38208    |   0.0 |  0.38
Other   |            | 0.05892    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.863906841903, Press = 0.519545892372773
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  122000   -16027.339   -16027.339   -16104.033   -16104.033    296.81333    296.81333    36160.881    36160.881    1521.6939    1521.6939 
  123000   -16028.482   -16028.482   -16103.806   -16103.806    291.51098    291.51098    36142.752    36142.752    2408.4077    2408.4077 
Loop time of 99.8824 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.865 ns/day, 27.745 hours/ns, 10.012 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.373     | 99.373     | 99.373     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076341   | 0.076341   | 0.076341   |   0.0 |  0.08
Output  | 0.00015427 | 0.00015427 | 0.00015427 |   0.0 |  0.00
Modify  | 0.37431    | 0.37431    | 0.37431    |   0.0 |  0.37
Other   |            | 0.05827    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.877971385836, Press = 0.567342762846434
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  123000   -16028.482   -16028.482   -16103.806   -16103.806    291.51098    291.51098    36142.752    36142.752    2408.4077    2408.4077 
  124000   -16027.298   -16027.298   -16101.165   -16101.165     285.8727     285.8727    36165.738    36165.738    1395.5466    1395.5466 
Loop time of 100.787 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.857 ns/day, 27.996 hours/ns, 9.922 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.27     | 100.27     | 100.27     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07778    | 0.07778    | 0.07778    |   0.0 |  0.08
Output  | 0.0001533  | 0.0001533  | 0.0001533  |   0.0 |  0.00
Modify  | 0.37875    | 0.37875    | 0.37875    |   0.0 |  0.38
Other   |            | 0.05846    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.856537437784, Press = 0.620933742367421
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  124000   -16027.298   -16027.298   -16101.165   -16101.165     285.8727     285.8727    36165.738    36165.738    1395.5466    1395.5466 
  125000   -16027.953   -16027.953   -16101.994   -16101.994     286.5479     286.5479    36168.302    36168.302    1233.3719    1233.3719 
Loop time of 101.95 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.847 ns/day, 28.320 hours/ns, 9.809 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.43     | 101.43     | 101.43     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077171   | 0.077171   | 0.077171   |   0.0 |  0.08
Output  | 0.00015516 | 0.00015516 | 0.00015516 |   0.0 |  0.00
Modify  | 0.38566    | 0.38566    | 0.38566    |   0.0 |  0.38
Other   |            | 0.05935    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.848708983899, Press = 0.542084066088833
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  125000   -16027.953   -16027.953   -16101.994   -16101.994     286.5479     286.5479    36168.302    36168.302    1233.3719    1233.3719 
  126000   -16026.879   -16026.879   -16104.264   -16104.264    299.48823    299.48823    36191.023    36191.023   -28.443293   -28.443293 
Loop time of 101.222 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.854 ns/day, 28.117 hours/ns, 9.879 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.7      | 100.7      | 100.7      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077109   | 0.077109   | 0.077109   |   0.0 |  0.08
Output  | 0.00015455 | 0.00015455 | 0.00015455 |   0.0 |  0.00
Modify  | 0.382      | 0.382      | 0.382      |   0.0 |  0.38
Other   |            | 0.05798    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.828813039022, Press = 0.392804083517908
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  126000   -16026.879   -16026.879   -16104.264   -16104.264    299.48823    299.48823    36191.023    36191.023   -28.443293   -28.443293 
  127000   -16029.638   -16029.638   -16103.249   -16103.249     284.8805     284.8805    36180.598    36180.598    417.83591    417.83591 
Loop time of 101.741 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.849 ns/day, 28.262 hours/ns, 9.829 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.22     | 101.22     | 101.22     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077609   | 0.077609   | 0.077609   |   0.0 |  0.08
Output  | 0.0002673  | 0.0002673  | 0.0002673  |   0.0 |  0.00
Modify  | 0.3844     | 0.3844     | 0.3844     |   0.0 |  0.38
Other   |            | 0.05914    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.82807158754, Press = 0.397696971089988
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  127000   -16029.638   -16029.638   -16103.249   -16103.249     284.8805     284.8805    36180.598    36180.598    417.83591    417.83591 
  128000   -16026.874   -16026.874   -16102.399   -16102.399    292.29289    292.29289      36193.7      36193.7   -39.608739   -39.608739 
Loop time of 100.89 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.856 ns/day, 28.025 hours/ns, 9.912 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.37     | 100.37     | 100.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075891   | 0.075891   | 0.075891   |   0.0 |  0.08
Output  | 0.00015541 | 0.00015541 | 0.00015541 |   0.0 |  0.00
Modify  | 0.38194    | 0.38194    | 0.38194    |   0.0 |  0.38
Other   |            | 0.05841    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115970.0 ave      115970 max      115970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115970
Ave neighs/atom = 57.985000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.814044796396, Press = 0.287135394574506
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  128000   -16026.874   -16026.874   -16102.399   -16102.399    292.29289    292.29289      36193.7      36193.7   -39.608739   -39.608739 
  129000   -16027.671   -16027.671   -16102.678   -16102.678     290.2828     290.2828    36200.698    36200.698   -574.03423   -574.03423 
Loop time of 101.707 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.849 ns/day, 28.252 hours/ns, 9.832 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.19     | 101.19     | 101.19     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076757   | 0.076757   | 0.076757   |   0.0 |  0.08
Output  | 0.00020057 | 0.00020057 | 0.00020057 |   0.0 |  0.00
Modify  | 0.38508    | 0.38508    | 0.38508    |   0.0 |  0.38
Other   |            | 0.05888    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.807106434388, Press = 0.0343043456139381
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  129000   -16027.671   -16027.671   -16102.678   -16102.678     290.2828     290.2828    36200.698    36200.698   -574.03423   -574.03423 
  130000   -16027.455   -16027.455   -16102.467   -16102.467    290.30471    290.30471    36167.663    36167.663    1223.2707    1223.2707 
Loop time of 102.036 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.847 ns/day, 28.343 hours/ns, 9.800 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.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077664   | 0.077664   | 0.077664   |   0.0 |  0.08
Output  | 0.00015388 | 0.00015388 | 0.00015388 |   0.0 |  0.00
Modify  | 0.38801    | 0.38801    | 0.38801    |   0.0 |  0.38
Other   |            | 0.05872    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.78727156193, Press = 0.0635538997254052
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  130000   -16027.455   -16027.455   -16102.467   -16102.467    290.30471    290.30471    36167.663    36167.663    1223.2707    1223.2707 
  131000   -16026.213   -16026.213   -16102.147   -16102.147    293.87061    293.87061      36149.8      36149.8    2267.2152    2267.2152 
Loop time of 103.388 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.719 hours/ns, 9.672 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    | 102.86     | 102.86     | 102.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077817   | 0.077817   | 0.077817   |   0.0 |  0.08
Output  | 0.00019021 | 0.00019021 | 0.00019021 |   0.0 |  0.00
Modify  | 0.3925     | 0.3925     | 0.3925     |   0.0 |  0.38
Other   |            | 0.05971    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.778569816007, Press = 0.168567580171408
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  131000   -16026.213   -16026.213   -16102.147   -16102.147    293.87061    293.87061      36149.8      36149.8    2267.2152    2267.2152 
  132000   -16028.316   -16028.316   -16104.259   -16104.259    293.90935    293.90935    36168.134    36168.134    1125.3259    1125.3259 
Loop time of 101.754 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.849 ns/day, 28.265 hours/ns, 9.828 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.23     | 101.23     | 101.23     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077348   | 0.077348   | 0.077348   |   0.0 |  0.08
Output  | 0.0001541  | 0.0001541  | 0.0001541  |   0.0 |  0.00
Modify  | 0.38467    | 0.38467    | 0.38467    |   0.0 |  0.38
Other   |            | 0.05844    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115992.0 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.764772729041, Press = 0.195704732207773
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  132000   -16028.316   -16028.316   -16104.259   -16104.259    293.90935    293.90935    36168.134    36168.134    1125.3259    1125.3259 
  133000   -16027.613   -16027.613   -16102.679   -16102.679    290.51373    290.51373    36187.812    36187.812    130.66047    130.66047 
Loop time of 98.6981 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.416 hours/ns, 10.132 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    | 98.193     | 98.193     | 98.193     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075809   | 0.075809   | 0.075809   |   0.0 |  0.08
Output  | 0.00015449 | 0.00015449 | 0.00015449 |   0.0 |  0.00
Modify  | 0.37097    | 0.37097    | 0.37097    |   0.0 |  0.38
Other   |            | 0.05808    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.763780769072, Press = 0.487320539160829
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  133000   -16027.613   -16027.613   -16102.679   -16102.679    290.51373    290.51373    36187.812    36187.812    130.66047    130.66047 
  134000   -16026.332   -16026.332   -16102.385   -16102.385    294.33295    294.33295    36224.135    36224.135   -1771.5966   -1771.5966 
Loop time of 98.2907 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.303 hours/ns, 10.174 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    | 97.792     | 97.792     | 97.792     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07448    | 0.07448    | 0.07448    |   0.0 |  0.08
Output  | 0.00015444 | 0.00015444 | 0.00015444 |   0.0 |  0.00
Modify  | 0.36607    | 0.36607    | 0.36607    |   0.0 |  0.37
Other   |            | 0.0578     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.759993858743, Press = 0.149817923878759
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  134000   -16026.332   -16026.332   -16102.385   -16102.385    294.33295    294.33295    36224.135    36224.135   -1771.5966   -1771.5966 
  135000   -16027.093   -16027.093   -16102.737   -16102.737    292.75304    292.75304    36226.129    36226.129   -1842.8392   -1842.8392 
Loop time of 101.405 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.852 ns/day, 28.168 hours/ns, 9.861 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.89     | 100.89     | 100.89     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076895   | 0.076895   | 0.076895   |   0.0 |  0.08
Output  | 0.00015349 | 0.00015349 | 0.00015349 |   0.0 |  0.00
Modify  | 0.3829     | 0.3829     | 0.3829     |   0.0 |  0.38
Other   |            | 0.05882    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.764117566329, Press = 0.107117037256018
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  135000   -16027.093   -16027.093   -16102.737   -16102.737    292.75304    292.75304    36226.129    36226.129   -1842.8392   -1842.8392 
  136000   -16028.498   -16028.498   -16103.996   -16103.996    292.18264    292.18264    36229.148    36229.148   -2144.4197   -2144.4197 
Loop time of 103.202 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.667 hours/ns, 9.690 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.67     | 102.67     | 102.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078101   | 0.078101   | 0.078101   |   0.0 |  0.08
Output  | 0.00015651 | 0.00015651 | 0.00015651 |   0.0 |  0.00
Modify  | 0.39238    | 0.39238    | 0.39238    |   0.0 |  0.38
Other   |            | 0.0593     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.736067025956, Press = 0.132524528674761
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  136000   -16028.498   -16028.498   -16103.996   -16103.996    292.18264    292.18264    36229.148    36229.148   -2144.4197   -2144.4197 
  137000   -16027.708   -16027.708   -16102.379   -16102.379    288.98819    288.98819    36232.432    36232.432   -2157.5872   -2157.5872 
Loop time of 100.623 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.859 ns/day, 27.951 hours/ns, 9.938 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.11     | 100.11     | 100.11     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076137   | 0.076137   | 0.076137   |   0.0 |  0.08
Output  | 0.00015435 | 0.00015435 | 0.00015435 |   0.0 |  0.00
Modify  | 0.37689    | 0.37689    | 0.37689    |   0.0 |  0.37
Other   |            | 0.05806    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.733989370716, Press = 0.135392830270142
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  137000   -16027.708   -16027.708   -16102.379   -16102.379    288.98819    288.98819    36232.432    36232.432   -2157.5872   -2157.5872 
  138000   -16024.522   -16024.522   -16100.298   -16100.298    293.26101    293.26101    36231.616    36231.616    -1912.143    -1912.143 
Loop time of 102.931 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.592 hours/ns, 9.715 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    | 102.4      | 102.4      | 102.4      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078068   | 0.078068   | 0.078068   |   0.0 |  0.08
Output  | 0.00015793 | 0.00015793 | 0.00015793 |   0.0 |  0.00
Modify  | 0.39203    | 0.39203    | 0.39203    |   0.0 |  0.38
Other   |            | 0.05921    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115972.0 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.739728431616, Press = 0.209974852349426
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  138000   -16024.522   -16024.522   -16100.298   -16100.298    293.26101    293.26101    36231.616    36231.616    -1912.143    -1912.143 
  139000   -16026.921   -16026.921   -16103.263   -16103.263    295.45023    295.45023    36257.089    36257.089    -3529.792    -3529.792 
Loop time of 100.244 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.862 ns/day, 27.845 hours/ns, 9.976 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.732     | 99.732     | 99.732     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075986   | 0.075986   | 0.075986   |   0.0 |  0.08
Output  | 0.00015588 | 0.00015588 | 0.00015588 |   0.0 |  0.00
Modify  | 0.3767     | 0.3767     | 0.3767     |   0.0 |  0.38
Other   |            | 0.05836    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.755289630933, Press = 0.230426181416478
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  139000   -16026.921   -16026.921   -16103.263   -16103.263    295.45023    295.45023    36257.089    36257.089    -3529.792    -3529.792 
  140000   -16024.196   -16024.196    -16101.35    -16101.35    298.59355    298.59355    36220.901    36220.901   -1411.2592   -1411.2592 
Loop time of 102.303 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.418 hours/ns, 9.775 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.78     | 101.78     | 101.78     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078846   | 0.078846   | 0.078846   |   0.0 |  0.08
Output  | 0.00026546 | 0.00026546 | 0.00026546 |   0.0 |  0.00
Modify  | 0.38917    | 0.38917    | 0.38917    |   0.0 |  0.38
Other   |            | 0.05819    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.770686443598, Press = 0.204231673228107
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  140000   -16024.196   -16024.196    -16101.35    -16101.35    298.59355    298.59355    36220.901    36220.901   -1411.2592   -1411.2592 
  141000   -16027.006   -16027.006   -16101.206   -16101.206    287.16352    287.16352    36218.267    36218.267   -1329.0799   -1329.0799 
Loop time of 102.222 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.395 hours/ns, 9.783 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.7      | 101.7      | 101.7      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077971   | 0.077971   | 0.077971   |   0.0 |  0.08
Output  | 0.00015769 | 0.00015769 | 0.00015769 |   0.0 |  0.00
Modify  | 0.3889     | 0.3889     | 0.3889     |   0.0 |  0.38
Other   |            | 0.0583     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.781064222849, Press = 0.313853977269807
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  141000   -16027.006   -16027.006   -16101.206   -16101.206    287.16352    287.16352    36218.267    36218.267   -1329.0799   -1329.0799 
  142000   -16023.035   -16023.035   -16099.049   -16099.049    294.18258    294.18258    36212.929    36212.929   -893.32125   -893.32125 
Loop time of 97.5062 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.886 ns/day, 27.085 hours/ns, 10.256 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    | 97.012     | 97.012     | 97.012     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074577   | 0.074577   | 0.074577   |   0.0 |  0.08
Output  | 0.00015019 | 0.00015019 | 0.00015019 |   0.0 |  0.00
Modify  | 0.36248    | 0.36248    | 0.36248    |   0.0 |  0.37
Other   |            | 0.0568     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.796078636146, Press = 0.34273397306542
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  142000   -16023.035   -16023.035   -16099.049   -16099.049    294.18258    294.18258    36212.929    36212.929   -893.32125   -893.32125 
  143000    -16026.62    -16026.62   -16102.229   -16102.229    292.61387    292.61387    36241.748    36241.748   -2614.6798   -2614.6798 
Loop time of 100.681 on 1 procs for 1000 steps with 2000 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    | 100.17     | 100.17     | 100.17     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075455   | 0.075455   | 0.075455   |   0.0 |  0.07
Output  | 0.00020154 | 0.00020154 | 0.00020154 |   0.0 |  0.00
Modify  | 0.37429    | 0.37429    | 0.37429    |   0.0 |  0.37
Other   |            | 0.05841    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.809378232435, Press = 0.545002292082638
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  143000    -16026.62    -16026.62   -16102.229   -16102.229    292.61387    292.61387    36241.748    36241.748   -2614.6798   -2614.6798 
  144000   -16024.036   -16024.036    -16099.39    -16099.39    291.62644    291.62644    36226.578    36226.578   -1655.4193   -1655.4193 
Loop time of 98.0653 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.240 hours/ns, 10.197 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    | 97.569     | 97.569     | 97.569     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075066   | 0.075066   | 0.075066   |   0.0 |  0.08
Output  | 0.00018977 | 0.00018977 | 0.00018977 |   0.0 |  0.00
Modify  | 0.36338    | 0.36338    | 0.36338    |   0.0 |  0.37
Other   |            | 0.05734    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.822975949841, Press = 0.308188639954965
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  144000   -16024.036   -16024.036    -16099.39    -16099.39    291.62644    291.62644    36226.578    36226.578   -1655.4193   -1655.4193 
  145000   -16028.337   -16028.337   -16102.905   -16102.905    288.58656    288.58656    36177.064    36177.064    698.10086    698.10086 
Loop time of 98.0783 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.244 hours/ns, 10.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    | 97.585     | 97.585     | 97.585     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074156   | 0.074156   | 0.074156   |   0.0 |  0.08
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.36146    | 0.36146    | 0.36146    |   0.0 |  0.37
Other   |            | 0.05727    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.835790334873, Press = 0.381557435408859
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  145000   -16028.337   -16028.337   -16102.905   -16102.905    288.58656    288.58656    36177.064    36177.064    698.10086    698.10086 
  146000   -16024.947   -16024.947   -16102.677   -16102.677    300.82326    300.82326    36201.931    36201.931     -645.853     -645.853 
Loop time of 97.1398 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.889 ns/day, 26.983 hours/ns, 10.294 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    | 96.648     | 96.648     | 96.648     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074545   | 0.074545   | 0.074545   |   0.0 |  0.08
Output  | 0.00015473 | 0.00015473 | 0.00015473 |   0.0 |  0.00
Modify  | 0.35976    | 0.35976    | 0.35976    |   0.0 |  0.37
Other   |            | 0.05713    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.828377355056, Press = 0.248850949754687
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  146000   -16024.947   -16024.947   -16102.677   -16102.677    300.82326    300.82326    36201.931    36201.931     -645.853     -645.853 
  147000   -16026.475   -16026.475    -16101.53    -16101.53    290.47123    290.47123    36166.894    36166.894    1329.6401    1329.6401 
Loop time of 99.2243 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.562 hours/ns, 10.078 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    | 98.718     | 98.718     | 98.718     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075878   | 0.075878   | 0.075878   |   0.0 |  0.08
Output  | 0.00015387 | 0.00015387 | 0.00015387 |   0.0 |  0.00
Modify  | 0.37197    | 0.37197    | 0.37197    |   0.0 |  0.37
Other   |            | 0.0579     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115992.0 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.82556353459, Press = 0.267376798211722
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  147000   -16026.475   -16026.475    -16101.53    -16101.53    290.47123    290.47123    36166.894    36166.894    1329.6401    1329.6401 
  148000   -16026.335   -16026.335   -16103.159   -16103.159    297.31459    297.31459    36185.527    36185.527    262.10268    262.10268 
Loop time of 98.3794 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.328 hours/ns, 10.165 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    | 97.88      | 97.88      | 97.88      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074897   | 0.074897   | 0.074897   |   0.0 |  0.08
Output  | 0.00015672 | 0.00015672 | 0.00015672 |   0.0 |  0.00
Modify  | 0.36673    | 0.36673    | 0.36673    |   0.0 |  0.37
Other   |            | 0.0575     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.82093331679, Press = 0.331976257450816
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  148000   -16026.335   -16026.335   -16103.159   -16103.159    297.31459    297.31459    36185.527    36185.527    262.10268    262.10268 
  149000   -16027.003   -16027.003   -16102.068   -16102.068    290.51099    290.51099    36195.886    36195.886   -259.62559   -259.62559 
Loop time of 102.302 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.417 hours/ns, 9.775 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.78     | 101.78     | 101.78     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076736   | 0.076736   | 0.076736   |   0.0 |  0.08
Output  | 0.00015741 | 0.00015741 | 0.00015741 |   0.0 |  0.00
Modify  | 0.38661    | 0.38661    | 0.38661    |   0.0 |  0.38
Other   |            | 0.05901    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.824176005167, Press = 0.104783246949839
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  149000   -16027.003   -16027.003   -16102.068   -16102.068    290.51099    290.51099    36195.886    36195.886   -259.62559   -259.62559 
  150000   -16026.237   -16026.237   -16100.957   -16100.957    289.17335    289.17335    36148.109    36148.109     2451.601     2451.601 
Loop time of 106.173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.493 hours/ns, 9.419 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.63     | 105.63     | 105.63     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078807   | 0.078807   | 0.078807   |   0.0 |  0.07
Output  | 0.00015613 | 0.00015613 | 0.00015613 |   0.0 |  0.00
Modify  | 0.40425    | 0.40425    | 0.40425    |   0.0 |  0.38
Other   |            | 0.05993    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.819829065929, Press = 0.144142846358719
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  150000   -16026.237   -16026.237   -16100.957   -16100.957    289.17335    289.17335    36148.109    36148.109     2451.601     2451.601 
  151000    -16028.78    -16028.78   -16103.494   -16103.494    289.15084    289.15084    36186.598    36186.598    96.935935    96.935935 
Loop time of 101.736 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.849 ns/day, 28.260 hours/ns, 9.829 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.22     | 101.22     | 101.22     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077276   | 0.077276   | 0.077276   |   0.0 |  0.08
Output  | 0.00015487 | 0.00015487 | 0.00015487 |   0.0 |  0.00
Modify  | 0.38303    | 0.38303    | 0.38303    |   0.0 |  0.38
Other   |            | 0.05851    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.817862842692, Press = 0.208765373772534
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  151000    -16028.78    -16028.78   -16103.494   -16103.494    289.15084    289.15084    36186.598    36186.598    96.935935    96.935935 
  152000   -16027.889   -16027.889   -16102.429   -16102.429    288.47878    288.47878    36168.466    36168.466    1181.8557    1181.8557 
Loop time of 99.9665 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.864 ns/day, 27.768 hours/ns, 10.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    | 99.456     | 99.456     | 99.456     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076211   | 0.076211   | 0.076211   |   0.0 |  0.08
Output  | 0.000203   | 0.000203   | 0.000203   |   0.0 |  0.00
Modify  | 0.3757     | 0.3757     | 0.3757     |   0.0 |  0.38
Other   |            | 0.05836    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.82705519351, Press = 0.252707761305632
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  152000   -16027.889   -16027.889   -16102.429   -16102.429    288.47878    288.47878    36168.466    36168.466    1181.8557    1181.8557 
  153000   -16027.022   -16027.022   -16101.376   -16101.376    287.75838    287.75838    36185.679    36185.679     272.4558     272.4558 
Loop time of 101.952 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.847 ns/day, 28.320 hours/ns, 9.809 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.43     | 101.43     | 101.43     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076792   | 0.076792   | 0.076792   |   0.0 |  0.08
Output  | 0.00045933 | 0.00045933 | 0.00045933 |   0.0 |  0.00
Modify  | 0.38736    | 0.38736    | 0.38736    |   0.0 |  0.38
Other   |            | 0.0593     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.817198447338, Press = 0.217683184871748
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  153000   -16027.022   -16027.022   -16101.376   -16101.376    287.75838    287.75838    36185.679    36185.679     272.4558     272.4558 
  154000   -16028.427   -16028.427   -16103.279   -16103.279    289.68836    289.68836    36155.709    36155.709    1783.1381    1783.1381 
Loop time of 103.95 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.875 hours/ns, 9.620 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.42     | 103.42     | 103.42     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07861    | 0.07861    | 0.07861    |   0.0 |  0.08
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.39415    | 0.39415    | 0.39415    |   0.0 |  0.38
Other   |            | 0.05919    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.816609905505, Press = 0.431160736314123
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  154000   -16028.427   -16028.427   -16103.279   -16103.279    289.68836    289.68836    36155.709    36155.709    1783.1381    1783.1381 
  155000   -16025.543   -16025.543   -16102.599   -16102.599    298.21183    298.21183    36183.007    36183.007    408.17968    408.17968 
Loop time of 99.634 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.867 ns/day, 27.676 hours/ns, 10.037 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.128     | 99.128     | 99.128     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075277   | 0.075277   | 0.075277   |   0.0 |  0.08
Output  | 0.00015956 | 0.00015956 | 0.00015956 |   0.0 |  0.00
Modify  | 0.37268    | 0.37268    | 0.37268    |   0.0 |  0.37
Other   |            | 0.05787    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.808168281065, Press = 0.563550123163661
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  155000   -16025.543   -16025.543   -16102.599   -16102.599    298.21183    298.21183    36183.007    36183.007    408.17968    408.17968 
  156000   -16028.261   -16028.261   -16103.564   -16103.564     291.4288     291.4288    36169.423    36169.423    1067.9278    1067.9278 
Loop time of 99.153 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.542 hours/ns, 10.085 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.652     | 98.652     | 98.652     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075883   | 0.075883   | 0.075883   |   0.0 |  0.08
Output  | 0.00015643 | 0.00015643 | 0.00015643 |   0.0 |  0.00
Modify  | 0.36748    | 0.36748    | 0.36748    |   0.0 |  0.37
Other   |            | 0.05721    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.81905461116, Press = 0.485776170935973
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  156000   -16028.261   -16028.261   -16103.564   -16103.564     291.4288     291.4288    36169.423    36169.423    1067.9278    1067.9278 
  157000   -16025.572   -16025.572   -16103.347   -16103.347    300.99687    300.99687    36202.555    36202.555   -626.49201   -626.49201 
Loop time of 103.041 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.622 hours/ns, 9.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    | 102.51     | 102.51     | 102.51     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078071   | 0.078071   | 0.078071   |   0.0 |  0.08
Output  | 0.00015497 | 0.00015497 | 0.00015497 |   0.0 |  0.00
Modify  | 0.39123    | 0.39123    | 0.39123    |   0.0 |  0.38
Other   |            | 0.0592     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.821418749422, Press = 0.276267845070077
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  157000   -16025.572   -16025.572   -16103.347   -16103.347    300.99687    300.99687    36202.555    36202.555   -626.49201   -626.49201 
  158000   -16027.563   -16027.563   -16101.888   -16101.888    287.64731    287.64731    36166.917    36166.917    1324.8492    1324.8492 
Loop time of 100.795 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.857 ns/day, 27.999 hours/ns, 9.921 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.28     | 100.28     | 100.28     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076338   | 0.076338   | 0.076338   |   0.0 |  0.08
Output  | 0.00015273 | 0.00015273 | 0.00015273 |   0.0 |  0.00
Modify  | 0.3772     | 0.3772     | 0.3772     |   0.0 |  0.37
Other   |            | 0.05814    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.819438553007, Press = 0.161736188900978
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  158000   -16027.563   -16027.563   -16101.888   -16101.888    287.64731    287.64731    36166.917    36166.917    1324.8492    1324.8492 
  159000   -16029.866   -16029.866   -16104.821   -16104.821    290.08478    290.08478    36195.786    36195.786   -489.71297   -489.71297 
Loop time of 98.0198 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.228 hours/ns, 10.202 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    | 97.524     | 97.524     | 97.524     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074604   | 0.074604   | 0.074604   |   0.0 |  0.08
Output  | 0.00015485 | 0.00015485 | 0.00015485 |   0.0 |  0.00
Modify  | 0.36312    | 0.36312    | 0.36312    |   0.0 |  0.37
Other   |            | 0.05745    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.805268997439, Press = 0.165327303852652
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  159000   -16029.866   -16029.866   -16104.821   -16104.821    290.08478    290.08478    36195.786    36195.786   -489.71297   -489.71297 
  160000   -16026.821   -16026.821    -16103.16    -16103.16    295.43889    295.43889    36216.757    36216.757   -1444.8439   -1444.8439 
Loop time of 99.085 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.524 hours/ns, 10.092 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    | 98.581     | 98.581     | 98.581     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075436   | 0.075436   | 0.075436   |   0.0 |  0.08
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.371      | 0.371      | 0.371      |   0.0 |  0.37
Other   |            | 0.05745    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.806580293152, Press = 0.111819744696689
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  160000   -16026.821   -16026.821    -16103.16    -16103.16    295.43889    295.43889    36216.757    36216.757   -1444.8439   -1444.8439 
  161000     -16025.7     -16025.7   -16101.644   -16101.644    293.91197    293.91197    36240.603    36240.603    -2439.908    -2439.908 
Loop time of 99.0345 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.510 hours/ns, 10.097 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    | 98.532     | 98.532     | 98.532     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075135   | 0.075135   | 0.075135   |   0.0 |  0.08
Output  | 0.00015438 | 0.00015438 | 0.00015438 |   0.0 |  0.00
Modify  | 0.36959    | 0.36959    | 0.36959    |   0.0 |  0.37
Other   |            | 0.05741    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115992.0 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.791617781277, Press = 0.139725305633325
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  161000     -16025.7     -16025.7   -16101.644   -16101.644    293.91197    293.91197    36240.603    36240.603    -2439.908    -2439.908 
  162000    -16025.15    -16025.15   -16100.876   -16100.876     293.0663     293.0663    36237.293    36237.293   -2223.4603   -2223.4603 
Loop time of 99.0463 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.513 hours/ns, 10.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    | 98.542     | 98.542     | 98.542     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075847   | 0.075847   | 0.075847   |   0.0 |  0.08
Output  | 0.00019886 | 0.00019886 | 0.00019886 |   0.0 |  0.00
Modify  | 0.37049    | 0.37049    | 0.37049    |   0.0 |  0.37
Other   |            | 0.05749    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115972.0 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.785699310577, Press = 0.0148443820072683
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  162000    -16025.15    -16025.15   -16100.876   -16100.876     293.0663     293.0663    36237.293    36237.293   -2223.4603   -2223.4603 
  163000   -16028.612   -16028.612   -16104.695   -16104.695    294.44719    294.44719    36226.163    36226.163   -2001.2226   -2001.2226 
Loop time of 104.463 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.017 hours/ns, 9.573 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.93     | 103.93     | 103.93     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078412   | 0.078412   | 0.078412   |   0.0 |  0.08
Output  | 0.00015505 | 0.00015505 | 0.00015505 |   0.0 |  0.00
Modify  | 0.39859    | 0.39859    | 0.39859    |   0.0 |  0.38
Other   |            | 0.05977    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.775708762193, Press = 0.0859581318608992
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  163000   -16028.612   -16028.612   -16104.695   -16104.695    294.44719    294.44719    36226.163    36226.163   -2001.2226   -2001.2226 
  164000   -16025.552   -16025.552   -16101.909   -16101.909    295.50881    295.50881    36201.051    36201.051   -379.43767   -379.43767 
Loop time of 99.9873 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.864 ns/day, 27.774 hours/ns, 10.001 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.477     | 99.477     | 99.477     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076066   | 0.076066   | 0.076066   |   0.0 |  0.08
Output  | 0.00015557 | 0.00015557 | 0.00015557 |   0.0 |  0.00
Modify  | 0.37564    | 0.37564    | 0.37564    |   0.0 |  0.38
Other   |            | 0.05877    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.772686013462, Press = 0.0840984670411236
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  164000   -16025.552   -16025.552   -16101.909   -16101.909    295.50881    295.50881    36201.051    36201.051   -379.43767   -379.43767 
  165000   -16028.245   -16028.245   -16104.072   -16104.072    293.45613    293.45613    36188.906    36188.906   -5.6800111   -5.6800111 
Loop time of 97.934 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.204 hours/ns, 10.211 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    | 97.439     | 97.439     | 97.439     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074523   | 0.074523   | 0.074523   |   0.0 |  0.08
Output  | 0.00014976 | 0.00014976 | 0.00014976 |   0.0 |  0.00
Modify  | 0.36288    | 0.36288    | 0.36288    |   0.0 |  0.37
Other   |            | 0.05708    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.76032833111, Press = 0.150554396285998
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  165000   -16028.245   -16028.245   -16104.072   -16104.072    293.45613    293.45613    36188.906    36188.906   -5.6800111   -5.6800111 
  166000   -16025.533   -16025.533    -16101.07    -16101.07    292.33606    292.33606    36166.378    36166.378    1486.3289    1486.3289 
Loop time of 102.208 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.391 hours/ns, 9.784 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.69     | 101.69     | 101.69     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076968   | 0.076968   | 0.076968   |   0.0 |  0.08
Output  | 0.00015568 | 0.00015568 | 0.00015568 |   0.0 |  0.00
Modify  | 0.3859     | 0.3859     | 0.3859     |   0.0 |  0.38
Other   |            | 0.05967    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.760780351934, Press = 0.188473710792958
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  166000   -16025.533   -16025.533    -16101.07    -16101.07    292.33606    292.33606    36166.378    36166.378    1486.3289    1486.3289 
  167000    -16028.12    -16028.12   -16103.196   -16103.196    290.55191    290.55191    36165.154    36165.154    1328.2545    1328.2545 
Loop time of 98.3379 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.316 hours/ns, 10.169 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    | 97.839     | 97.839     | 97.839     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075515   | 0.075515   | 0.075515   |   0.0 |  0.08
Output  | 0.00015441 | 0.00015441 | 0.00015441 |   0.0 |  0.00
Modify  | 0.36548    | 0.36548    | 0.36548    |   0.0 |  0.37
Other   |            | 0.05774    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.760071800948, Press = 0.263205934089579
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  167000    -16028.12    -16028.12   -16103.196   -16103.196    290.55191    290.55191    36165.154    36165.154    1328.2545    1328.2545 
  168000   -16024.485   -16024.485   -16101.939   -16101.939    299.75257    299.75257    36138.738    36138.738    2907.2428    2907.2428 
Loop time of 101.54 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.851 ns/day, 28.205 hours/ns, 9.848 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.01     | 101.01     | 101.01     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078334   | 0.078334   | 0.078334   |   0.0 |  0.08
Output  | 0.00015763 | 0.00015763 | 0.00015763 |   0.0 |  0.00
Modify  | 0.38742    | 0.38742    | 0.38742    |   0.0 |  0.38
Other   |            | 0.05917    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.781967895971, Press = 0.36697203523824
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  168000   -16024.485   -16024.485   -16101.939   -16101.939    299.75257    299.75257    36138.738    36138.738    2907.2428    2907.2428 
  169000   -16028.189   -16028.189   -16102.225   -16102.225    286.52821    286.52821     36151.39     36151.39     2107.374     2107.374 
Loop time of 97.4194 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.061 hours/ns, 10.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    | 96.927     | 96.927     | 96.927     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07455    | 0.07455    | 0.07455    |   0.0 |  0.08
Output  | 0.00015652 | 0.00015652 | 0.00015652 |   0.0 |  0.00
Modify  | 0.36093    | 0.36093    | 0.36093    |   0.0 |  0.37
Other   |            | 0.05685    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.789833344116, Press = 0.446306473336835
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  169000   -16028.189   -16028.189   -16102.225   -16102.225    286.52821    286.52821     36151.39     36151.39     2107.374     2107.374 
  170000   -16027.308   -16027.308   -16101.577   -16101.577    287.42782    287.42782    36177.302    36177.302    820.36336    820.36336 
Loop time of 101.906 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.848 ns/day, 28.307 hours/ns, 9.813 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.38     | 101.38     | 101.38     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077091   | 0.077091   | 0.077091   |   0.0 |  0.08
Output  | 0.00024503 | 0.00024503 | 0.00024503 |   0.0 |  0.00
Modify  | 0.38711    | 0.38711    | 0.38711    |   0.0 |  0.38
Other   |            | 0.0587     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.804621744718, Press = 0.134974403160591
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  170000   -16027.308   -16027.308   -16101.577   -16101.577    287.42782    287.42782    36177.302    36177.302    820.36336    820.36336 
  171000    -16029.94    -16029.94   -16101.662   -16101.662    277.57135    277.57135    36173.386    36173.386    907.30406    907.30406 
Loop time of 102.651 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.842 ns/day, 28.514 hours/ns, 9.742 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.12     | 102.12     | 102.12     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077562   | 0.077562   | 0.077562   |   0.0 |  0.08
Output  | 0.00019705 | 0.00019705 | 0.00019705 |   0.0 |  0.00
Modify  | 0.39068    | 0.39068    | 0.39068    |   0.0 |  0.38
Other   |            | 0.05994    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.799469556699, Press = 0.161470906473705
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  171000    -16029.94    -16029.94   -16101.662   -16101.662    277.57135    277.57135    36173.386    36173.386    907.30406    907.30406 
  172000   -16026.539   -16026.539   -16102.642   -16102.642    294.52564    294.52564    36168.468    36168.468    1290.1238    1290.1238 
Loop time of 102.259 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.405 hours/ns, 9.779 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.73     | 101.73     | 101.73     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077535   | 0.077535   | 0.077535   |   0.0 |  0.08
Output  | 0.00019564 | 0.00019564 | 0.00019564 |   0.0 |  0.00
Modify  | 0.38728    | 0.38728    | 0.38728    |   0.0 |  0.38
Other   |            | 0.05887    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.795175072132, Press = 0.292921914394445
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  172000   -16026.539   -16026.539   -16102.642   -16102.642    294.52564    294.52564    36168.468    36168.468    1290.1238    1290.1238 
  173000    -16027.41    -16027.41   -16102.101   -16102.101    289.06208    289.06208    36173.572    36173.572    926.72187    926.72187 
Loop time of 100.024 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.864 ns/day, 27.785 hours/ns, 9.998 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.512     | 99.512     | 99.512     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075897   | 0.075897   | 0.075897   |   0.0 |  0.08
Output  | 0.0001554  | 0.0001554  | 0.0001554  |   0.0 |  0.00
Modify  | 0.37826    | 0.37826    | 0.37826    |   0.0 |  0.38
Other   |            | 0.05835    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.796123243898, Press = 0.196503391819779
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  173000    -16027.41    -16027.41   -16102.101   -16102.101    289.06208    289.06208    36173.572    36173.572    926.72187    926.72187 
  174000    -16027.61    -16027.61   -16104.136   -16104.136    296.16264    296.16264    36177.231    36177.231    619.10711    619.10711 
Loop time of 99.2076 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.558 hours/ns, 10.080 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.705     | 98.705     | 98.705     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075238   | 0.075238   | 0.075238   |   0.0 |  0.08
Output  | 0.00015456 | 0.00015456 | 0.00015456 |   0.0 |  0.00
Modify  | 0.36854    | 0.36854    | 0.36854    |   0.0 |  0.37
Other   |            | 0.05844    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.802693186398, Press = 0.181799980731093
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  174000    -16027.61    -16027.61   -16104.136   -16104.136    296.16264    296.16264    36177.231    36177.231    619.10711    619.10711 
  175000   -16024.309   -16024.309   -16100.696   -16100.696    295.62584    295.62584    36169.201    36169.201    1339.3689    1339.3689 
Loop time of 102.752 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.841 ns/day, 28.542 hours/ns, 9.732 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.23     | 102.23     | 102.23     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078779   | 0.078779   | 0.078779   |   0.0 |  0.08
Output  | 0.00015505 | 0.00015505 | 0.00015505 |   0.0 |  0.00
Modify  | 0.38727    | 0.38727    | 0.38727    |   0.0 |  0.38
Other   |            | 0.05922    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.813666924523, Press = 0.0205739095556383
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  175000   -16024.309   -16024.309   -16100.696   -16100.696    295.62584    295.62584    36169.201    36169.201    1339.3689    1339.3689 
  176000   -16024.499   -16024.499   -16100.497   -16100.497    294.11957    294.11957    36113.103    36113.103    4378.9522    4378.9522 
Loop time of 101.1 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.855 ns/day, 28.083 hours/ns, 9.891 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.59     | 100.59     | 100.59     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07639    | 0.07639    | 0.07639    |   0.0 |  0.08
Output  | 0.00015521 | 0.00015521 | 0.00015521 |   0.0 |  0.00
Modify  | 0.37877    | 0.37877    | 0.37877    |   0.0 |  0.37
Other   |            | 0.05861    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.820915704581, Press = 0.0701337305876469
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  176000   -16024.499   -16024.499   -16100.497   -16100.497    294.11957    294.11957    36113.103    36113.103    4378.9522    4378.9522 
  177000    -16026.48    -16026.48   -16103.535   -16103.535    298.20795    298.20795    36173.817    36173.817     834.5124     834.5124 
Loop time of 98.9333 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.481 hours/ns, 10.108 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    | 98.431     | 98.431     | 98.431     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075663   | 0.075663   | 0.075663   |   0.0 |  0.08
Output  | 0.00015322 | 0.00015322 | 0.00015322 |   0.0 |  0.00
Modify  | 0.36935    | 0.36935    | 0.36935    |   0.0 |  0.37
Other   |            | 0.05754    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.831827028658, Press = 0.171879754540557
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  177000    -16026.48    -16026.48   -16103.535   -16103.535    298.20795    298.20795    36173.817    36173.817     834.5124     834.5124 
  178000   -16026.785   -16026.785   -16102.441   -16102.441    292.79467    292.79467    36176.202    36176.202     897.1289     897.1289 
Loop time of 101.81 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.849 ns/day, 28.281 hours/ns, 9.822 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.29     | 101.29     | 101.29     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077592   | 0.077592   | 0.077592   |   0.0 |  0.08
Output  | 0.00015549 | 0.00015549 | 0.00015549 |   0.0 |  0.00
Modify  | 0.38303    | 0.38303    | 0.38303    |   0.0 |  0.38
Other   |            | 0.0586     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.835989436072, Press = 0.202561182778097
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  178000   -16026.785   -16026.785   -16102.441   -16102.441    292.79467    292.79467    36176.202    36176.202     897.1289     897.1289 
  179000   -16026.336   -16026.336   -16102.873   -16102.873    296.20625    296.20625    36189.294    36189.294    102.57424    102.57424 
Loop time of 100.522 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.860 ns/day, 27.923 hours/ns, 9.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    | 100.01     | 100.01     | 100.01     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076682   | 0.076682   | 0.076682   |   0.0 |  0.08
Output  | 0.0001549  | 0.0001549  | 0.0001549  |   0.0 |  0.00
Modify  | 0.37824    | 0.37824    | 0.37824    |   0.0 |  0.38
Other   |            | 0.05819    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.833455059034, Press = 0.303509915000948
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  179000   -16026.336   -16026.336   -16102.873   -16102.873    296.20625    296.20625    36189.294    36189.294    102.57424    102.57424 
  180000   -16027.203   -16027.203    -16102.62    -16102.62    291.87036    291.87036    36184.817    36184.817    329.25907    329.25907 
Loop time of 98.6117 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.392 hours/ns, 10.141 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    | 98.11      | 98.11      | 98.11      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0753     | 0.0753     | 0.0753     |   0.0 |  0.08
Output  | 0.00015491 | 0.00015491 | 0.00015491 |   0.0 |  0.00
Modify  | 0.36865    | 0.36865    | 0.36865    |   0.0 |  0.37
Other   |            | 0.05789    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.85335583247, Press = 0.467632569601716
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  180000   -16027.203   -16027.203    -16102.62    -16102.62    291.87036    291.87036    36184.817    36184.817    329.25907    329.25907 
  181000   -16024.386   -16024.386   -16101.263   -16101.263    297.52277    297.52277    36169.748    36169.748    1197.2311    1197.2311 
Loop time of 102.212 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.392 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.69     | 101.69     | 101.69     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077278   | 0.077278   | 0.077278   |   0.0 |  0.08
Output  | 0.00015409 | 0.00015409 | 0.00015409 |   0.0 |  0.00
Modify  | 0.38789    | 0.38789    | 0.38789    |   0.0 |  0.38
Other   |            | 0.05964    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.849660963631, Press = 0.22469390212111
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  181000   -16024.386   -16024.386   -16101.263   -16101.263    297.52277    297.52277    36169.748    36169.748    1197.2311    1197.2311 
  182000   -16027.703   -16027.703   -16103.642   -16103.642    293.88997    293.88997    36137.833    36137.833    2767.2364    2767.2364 
Loop time of 98.3779 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.327 hours/ns, 10.165 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    | 97.876     | 97.876     | 97.876     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075043   | 0.075043   | 0.075043   |   0.0 |  0.08
Output  | 0.00015411 | 0.00015411 | 0.00015411 |   0.0 |  0.00
Modify  | 0.36911    | 0.36911    | 0.36911    |   0.0 |  0.38
Other   |            | 0.05728    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115992.0 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.85361747846, Press = 0.299824270003143
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  182000   -16027.703   -16027.703   -16103.642   -16103.642    293.88997    293.88997    36137.833    36137.833    2767.2364    2767.2364 
  183000   -16027.961   -16027.961   -16104.459   -16104.459     296.0554     296.0554    36140.536    36140.536    2531.4247    2531.4247 
Loop time of 100.972 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.856 ns/day, 28.048 hours/ns, 9.904 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.46     | 100.46     | 100.46     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077072   | 0.077072   | 0.077072   |   0.0 |  0.08
Output  | 0.00015458 | 0.00015458 | 0.00015458 |   0.0 |  0.00
Modify  | 0.37821    | 0.37821    | 0.37821    |   0.0 |  0.37
Other   |            | 0.05809    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.852092824217, Press = 0.306889524328817
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  183000   -16027.961   -16027.961   -16104.459   -16104.459     296.0554     296.0554    36140.536    36140.536    2531.4247    2531.4247 
  184000   -16025.536   -16025.536   -16103.623   -16103.623    302.20784    302.20784    36176.248    36176.248    738.11523    738.11523 
Loop time of 95.2198 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.907 ns/day, 26.450 hours/ns, 10.502 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    | 94.741     | 94.741     | 94.741     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07269    | 0.07269    | 0.07269    |   0.0 |  0.08
Output  | 0.00015631 | 0.00015631 | 0.00015631 |   0.0 |  0.00
Modify  | 0.34961    | 0.34961    | 0.34961    |   0.0 |  0.37
Other   |            | 0.05654    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115992.0 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.842640261796, Press = 0.403930586267102
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  184000   -16025.536   -16025.536   -16103.623   -16103.623    302.20784    302.20784    36176.248    36176.248    738.11523    738.11523 
  185000    -16027.42    -16027.42   -16101.414   -16101.414    286.36349    286.36349    36164.844    36164.844    1486.0497    1486.0497 
Loop time of 98.6664 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.407 hours/ns, 10.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    | 98.163     | 98.163     | 98.163     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075272   | 0.075272   | 0.075272   |   0.0 |  0.08
Output  | 0.00015825 | 0.00015825 | 0.00015825 |   0.0 |  0.00
Modify  | 0.37033    | 0.37033    | 0.37033    |   0.0 |  0.38
Other   |            | 0.0576     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.833986118482, Press = 0.165033232563068
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  185000    -16027.42    -16027.42   -16101.414   -16101.414    286.36349    286.36349    36164.844    36164.844    1486.0497    1486.0497 
  186000    -16024.27    -16024.27   -16100.675   -16100.675    295.69638    295.69638    36183.593    36183.593     605.1564     605.1564 
Loop time of 97.2356 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.889 ns/day, 27.010 hours/ns, 10.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    | 96.743     | 96.743     | 96.743     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074589   | 0.074589   | 0.074589   |   0.0 |  0.08
Output  | 0.00015833 | 0.00015833 | 0.00015833 |   0.0 |  0.00
Modify  | 0.36056    | 0.36056    | 0.36056    |   0.0 |  0.37
Other   |            | 0.05775    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.833616842557, Press = 0.373474240947862
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  186000    -16024.27    -16024.27   -16100.675   -16100.675    295.69638    295.69638    36183.593    36183.593     605.1564     605.1564 
  187000   -16023.432   -16023.432    -16101.91    -16101.91    303.71838    303.71838    36208.394    36208.394   -778.28164   -778.28164 
Loop time of 100.617 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.859 ns/day, 27.949 hours/ns, 9.939 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.1      | 100.1      | 100.1      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076687   | 0.076687   | 0.076687   |   0.0 |  0.08
Output  | 0.00024025 | 0.00024025 | 0.00024025 |   0.0 |  0.00
Modify  | 0.38055    | 0.38055    | 0.38055    |   0.0 |  0.38
Other   |            | 0.05822    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115972.0 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.838124771901, Press = 0.344802753325901
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  187000   -16023.432   -16023.432    -16101.91    -16101.91    303.71838    303.71838    36208.394    36208.394   -778.28164   -778.28164 
  188000   -16028.385   -16028.385   -16103.047   -16103.047      288.952      288.952    36162.273    36162.273    1569.3607    1569.3607 
Loop time of 98.7715 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.437 hours/ns, 10.124 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.264     | 98.264     | 98.264     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07607    | 0.07607    | 0.07607    |   0.0 |  0.08
Output  | 0.00019397 | 0.00019397 | 0.00019397 |   0.0 |  0.00
Modify  | 0.37362    | 0.37362    | 0.37362    |   0.0 |  0.38
Other   |            | 0.05782    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.849669139343, Press = 0.517399978791536
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  188000   -16028.385   -16028.385   -16103.047   -16103.047      288.952      288.952    36162.273    36162.273    1569.3607    1569.3607 
  189000    -16021.49    -16021.49   -16100.048   -16100.048    304.02802    304.02802    36189.108    36189.108    509.92607    509.92607 
Loop time of 97.8084 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.169 hours/ns, 10.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    | 97.313     | 97.313     | 97.313     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074951   | 0.074951   | 0.074951   |   0.0 |  0.08
Output  | 0.0001564  | 0.0001564  | 0.0001564  |   0.0 |  0.00
Modify  | 0.36278    | 0.36278    | 0.36278    |   0.0 |  0.37
Other   |            | 0.05789    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.860680488945, Press = 0.491745401127323
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  189000    -16021.49    -16021.49   -16100.048   -16100.048    304.02802    304.02802    36189.108    36189.108    509.92607    509.92607 
  190000   -16027.495   -16027.495   -16102.312   -16102.312    289.55188    289.55188    36168.927    36168.927    1223.3025    1223.3025 
Loop time of 96.8826 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.912 hours/ns, 10.322 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    | 96.394     | 96.394     | 96.394     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074282   | 0.074282   | 0.074282   |   0.0 |  0.08
Output  | 0.00015691 | 0.00015691 | 0.00015691 |   0.0 |  0.00
Modify  | 0.35762    | 0.35762    | 0.35762    |   0.0 |  0.37
Other   |            | 0.05669    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.861278697558, Press = 0.493658399917422
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  190000   -16027.495   -16027.495   -16102.312   -16102.312    289.55188    289.55188    36168.927    36168.927    1223.3025    1223.3025 
  191000   -16027.559   -16027.559   -16103.761   -16103.761    294.90803    294.90803     36206.88     36206.88   -878.17702   -878.17702 
Loop time of 100.393 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.861 ns/day, 27.887 hours/ns, 9.961 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.883     | 99.883     | 99.883     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076375   | 0.076375   | 0.076375   |   0.0 |  0.08
Output  | 0.00015507 | 0.00015507 | 0.00015507 |   0.0 |  0.00
Modify  | 0.37537    | 0.37537    | 0.37537    |   0.0 |  0.37
Other   |            | 0.05791    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.871173082863, Press = 0.338348520968799
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  191000   -16027.559   -16027.559   -16103.761   -16103.761    294.90803    294.90803     36206.88     36206.88   -878.17702   -878.17702 
  192000    -16022.55    -16022.55   -16100.139   -16100.139    300.27869    300.27869    36192.483    36192.483    278.53406    278.53406 
Loop time of 97.8081 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.169 hours/ns, 10.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    | 97.311     | 97.311     | 97.311     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075719   | 0.075719   | 0.075719   |   0.0 |  0.08
Output  | 0.00015636 | 0.00015636 | 0.00015636 |   0.0 |  0.00
Modify  | 0.3637     | 0.3637     | 0.3637     |   0.0 |  0.37
Other   |            | 0.05737    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.873899350755, Press = 0.331412639607326
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  192000    -16022.55    -16022.55   -16100.139   -16100.139    300.27869    300.27869    36192.483    36192.483    278.53406    278.53406 
  193000   -16026.811   -16026.811   -16103.575   -16103.575    297.08609    297.08609    36191.833    36191.833   -89.153965   -89.153965 
Loop time of 99.5404 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.650 hours/ns, 10.046 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.035     | 99.035     | 99.035     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076152   | 0.076152   | 0.076152   |   0.0 |  0.08
Output  | 0.00021206 | 0.00021206 | 0.00021206 |   0.0 |  0.00
Modify  | 0.37161    | 0.37161    | 0.37161    |   0.0 |  0.37
Other   |            | 0.05786    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.885730161807, Press = 0.267257870532351
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  193000   -16026.811   -16026.811   -16103.575   -16103.575    297.08609    297.08609    36191.833    36191.833   -89.153965   -89.153965 
  194000   -16028.369   -16028.369   -16103.305   -16103.305    290.01293    290.01293    36189.422    36189.422    7.7497941    7.7497941 
Loop time of 96.6206 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.839 hours/ns, 10.350 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    | 96.133     | 96.133     | 96.133     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073555   | 0.073555   | 0.073555   |   0.0 |  0.08
Output  | 0.0004565  | 0.0004565  | 0.0004565  |   0.0 |  0.00
Modify  | 0.35736    | 0.35736    | 0.35736    |   0.0 |  0.37
Other   |            | 0.05634    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.875241644966, Press = 0.180020747269016
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  194000   -16028.369   -16028.369   -16103.305   -16103.305    290.01293    290.01293    36189.422    36189.422    7.7497941    7.7497941 
  195000   -16025.254   -16025.254   -16100.628   -16100.628    291.70659    291.70659    36187.068    36187.068    423.02859    423.02859 
Loop time of 98.3323 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.315 hours/ns, 10.170 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    | 97.833     | 97.833     | 97.833     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075497   | 0.075497   | 0.075497   |   0.0 |  0.08
Output  | 0.00015324 | 0.00015324 | 0.00015324 |   0.0 |  0.00
Modify  | 0.36614    | 0.36614    | 0.36614    |   0.0 |  0.37
Other   |            | 0.05732    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.871590475064, Press = 0.348831853606396
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  195000   -16025.254   -16025.254   -16100.628   -16100.628    291.70659    291.70659    36187.068    36187.068    423.02859    423.02859 
  196000   -16030.564   -16030.564   -16104.713   -16104.713    286.96705    286.96705    36219.003    36219.003   -1733.1779   -1733.1779 
Loop time of 100.542 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.859 ns/day, 27.928 hours/ns, 9.946 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.03     | 100.03     | 100.03     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076776   | 0.076776   | 0.076776   |   0.0 |  0.08
Output  | 0.00015601 | 0.00015601 | 0.00015601 |   0.0 |  0.00
Modify  | 0.37809    | 0.37809    | 0.37809    |   0.0 |  0.38
Other   |            | 0.05793    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.860487453198, Press = 0.314513562078836
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  196000   -16030.564   -16030.564   -16104.713   -16104.713    286.96705    286.96705    36219.003    36219.003   -1733.1779   -1733.1779 
  197000   -16024.641   -16024.641   -16100.698   -16100.698    294.34925    294.34925    36190.181    36190.181    313.33031    313.33031 
Loop time of 102.479 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.466 hours/ns, 9.758 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.95     | 101.95     | 101.95     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077796   | 0.077796   | 0.077796   |   0.0 |  0.08
Output  | 0.00019767 | 0.00019767 | 0.00019767 |   0.0 |  0.00
Modify  | 0.39332    | 0.39332    | 0.39332    |   0.0 |  0.38
Other   |            | 0.05918    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.860208395894, Press = 0.359981603746856
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  197000   -16024.641   -16024.641   -16100.698   -16100.698    294.34925    294.34925    36190.181    36190.181    313.33031    313.33031 
  198000   -16028.345   -16028.345   -16104.472   -16104.472    294.62051    294.62051     36214.32     36214.32    -1434.722    -1434.722 
Loop time of 100.5 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.860 ns/day, 27.917 hours/ns, 9.950 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.988     | 99.988     | 99.988     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076111   | 0.076111   | 0.076111   |   0.0 |  0.08
Output  | 0.00015399 | 0.00015399 | 0.00015399 |   0.0 |  0.00
Modify  | 0.37785    | 0.37785    | 0.37785    |   0.0 |  0.38
Other   |            | 0.05825    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.87078106694, Press = 0.420277126318979
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  198000   -16028.345   -16028.345   -16104.472   -16104.472    294.62051    294.62051     36214.32     36214.32    -1434.722    -1434.722 
  199000   -16024.533   -16024.533   -16100.609   -16100.609    294.41984    294.41984    36208.758    36208.758   -749.72066   -749.72066 
Loop time of 98.46 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.350 hours/ns, 10.156 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    | 97.958     | 97.958     | 97.958     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075636   | 0.075636   | 0.075636   |   0.0 |  0.08
Output  | 0.00018867 | 0.00018867 | 0.00018867 |   0.0 |  0.00
Modify  | 0.36868    | 0.36868    | 0.36868    |   0.0 |  0.37
Other   |            | 0.05786    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.885336058377, Press = 0.287693162306254
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  199000   -16024.533   -16024.533   -16100.609   -16100.609    294.41984    294.41984    36208.758    36208.758   -749.72066   -749.72066 
  200000   -16026.122   -16026.122   -16102.887   -16102.887    297.08863    297.08863    36193.269    36193.269   -155.77696   -155.77696 
Loop time of 97.7893 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.164 hours/ns, 10.226 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    | 97.295     | 97.295     | 97.295     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074429   | 0.074429   | 0.074429   |   0.0 |  0.08
Output  | 0.00015449 | 0.00015449 | 0.00015449 |   0.0 |  0.00
Modify  | 0.36275    | 0.36275    | 0.36275    |   0.0 |  0.37
Other   |            | 0.05695    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.882597853871, Press = 0.190795463610955
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  200000   -16026.122   -16026.122   -16102.887   -16102.887    297.08863    297.08863    36193.269    36193.269   -155.77696   -155.77696 
  201000   -16027.641   -16027.641   -16103.362   -16103.362    293.05118    293.05118    36182.495    36182.495    390.73387    390.73387 
Loop time of 103.851 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.847 hours/ns, 9.629 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.32     | 103.32     | 103.32     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078871   | 0.078871   | 0.078871   |   0.0 |  0.08
Output  | 0.00015258 | 0.00015258 | 0.00015258 |   0.0 |  0.00
Modify  | 0.39136    | 0.39136    | 0.39136    |   0.0 |  0.38
Other   |            | 0.05922    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.887552728961, Press = 0.119562829139378
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  201000   -16027.641   -16027.641   -16103.362   -16103.362    293.05118    293.05118    36182.495    36182.495    390.73387    390.73387 
  202000   -16024.426   -16024.426   -16102.501   -16102.501     302.1578     302.1578    36160.246    36160.246    1757.0014    1757.0014 
Loop time of 97.8023 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.167 hours/ns, 10.225 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    | 97.305     | 97.305     | 97.305     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07467    | 0.07467    | 0.07467    |   0.0 |  0.08
Output  | 0.00015972 | 0.00015972 | 0.00015972 |   0.0 |  0.00
Modify  | 0.36487    | 0.36487    | 0.36487    |   0.0 |  0.37
Other   |            | 0.05768    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.899140288256, Press = 0.14491052558001
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  202000   -16024.426   -16024.426   -16102.501   -16102.501     302.1578     302.1578    36160.246    36160.246    1757.0014    1757.0014 
  203000   -16028.728   -16028.728   -16103.117   -16103.117    287.89342    287.89342    36142.816    36142.816    2450.3007    2450.3007 
Loop time of 100.329 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.861 ns/day, 27.869 hours/ns, 9.967 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.817     | 99.817     | 99.817     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076338   | 0.076338   | 0.076338   |   0.0 |  0.08
Output  | 0.00015456 | 0.00015456 | 0.00015456 |   0.0 |  0.00
Modify  | 0.37703    | 0.37703    | 0.37703    |   0.0 |  0.38
Other   |            | 0.05833    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.904830095461, Press = 0.293366482696287
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  203000   -16028.728   -16028.728   -16103.117   -16103.117    287.89342    287.89342    36142.816    36142.816    2450.3007    2450.3007 
  204000    -16023.87    -16023.87   -16102.411   -16102.411    303.96206    303.96206    36138.695    36138.695    2891.5624    2891.5624 
Loop time of 97.3753 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.049 hours/ns, 10.270 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    | 96.881     | 96.881     | 96.881     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074447   | 0.074447   | 0.074447   |   0.0 |  0.08
Output  | 0.00015436 | 0.00015436 | 0.00015436 |   0.0 |  0.00
Modify  | 0.36254    | 0.36254    | 0.36254    |   0.0 |  0.37
Other   |            | 0.05709    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.913059339244, Press = 0.251824448962872
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  204000    -16023.87    -16023.87   -16102.411   -16102.411    303.96206    303.96206    36138.695    36138.695    2891.5624    2891.5624 
  205000   -16028.701   -16028.701   -16103.201   -16103.201    288.32109    288.32109    36146.784    36146.784    2231.4572    2231.4572 
Loop time of 98.2436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.290 hours/ns, 10.179 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.742     | 97.742     | 97.742     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075767   | 0.075767   | 0.075767   |   0.0 |  0.08
Output  | 0.00015455 | 0.00015455 | 0.00015455 |   0.0 |  0.00
Modify  | 0.36734    | 0.36734    | 0.36734    |   0.0 |  0.37
Other   |            | 0.05802    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.903781411229, Press = 0.2627041373153
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  205000   -16028.701   -16028.701   -16103.201   -16103.201    288.32109    288.32109    36146.784    36146.784    2231.4572    2231.4572 
  206000   -16023.136   -16023.136   -16101.479   -16101.479    303.19601    303.19601    36173.871    36173.871    1125.2085    1125.2085 
Loop time of 99.4804 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.633 hours/ns, 10.052 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    | 98.976     | 98.976     | 98.976     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075732   | 0.075732   | 0.075732   |   0.0 |  0.08
Output  | 0.0001496  | 0.0001496  | 0.0001496  |   0.0 |  0.00
Modify  | 0.37043    | 0.37043    | 0.37043    |   0.0 |  0.37
Other   |            | 0.05805    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.907447540622, Press = 0.117633370854472
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  206000   -16023.136   -16023.136   -16101.479   -16101.479    303.19601    303.19601    36173.871    36173.871    1125.2085    1125.2085 
  207000   -16029.871   -16029.871   -16104.835   -16104.835    290.11704    290.11704    36185.206    36185.206    47.818962    47.818962 
Loop time of 98.0035 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.223 hours/ns, 10.204 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    | 97.505     | 97.505     | 97.505     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074903   | 0.074903   | 0.074903   |   0.0 |  0.08
Output  | 0.00015308 | 0.00015308 | 0.00015308 |   0.0 |  0.00
Modify  | 0.36573    | 0.36573    | 0.36573    |   0.0 |  0.37
Other   |            | 0.05736    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.899108234978, Press = 0.149292512355012
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  207000   -16029.871   -16029.871   -16104.835   -16104.835    290.11704    290.11704    36185.206    36185.206    47.818962    47.818962 
  208000   -16026.954   -16026.954   -16102.784   -16102.784    293.46952    293.46952    36198.542    36198.542    -432.8772    -432.8772 
Loop time of 97.9618 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.212 hours/ns, 10.208 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    | 97.465     | 97.465     | 97.465     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075414   | 0.075414   | 0.075414   |   0.0 |  0.08
Output  | 0.00019346 | 0.00019346 | 0.00019346 |   0.0 |  0.00
Modify  | 0.36438    | 0.36438    | 0.36438    |   0.0 |  0.37
Other   |            | 0.05694    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.894697457927, Press = -0.0684019240455391
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  208000   -16026.954   -16026.954   -16102.784   -16102.784    293.46952    293.46952    36198.542    36198.542    -432.8772    -432.8772 
  209000   -16026.903   -16026.903   -16102.006   -16102.006    290.65597    290.65597    36180.049    36180.049    593.62703    593.62703 
Loop time of 97.5652 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.886 ns/day, 27.101 hours/ns, 10.250 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    | 97.073     | 97.073     | 97.073     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07439    | 0.07439    | 0.07439    |   0.0 |  0.08
Output  | 0.00015845 | 0.00015845 | 0.00015845 |   0.0 |  0.00
Modify  | 0.3608     | 0.3608     | 0.3608     |   0.0 |  0.37
Other   |            | 0.05709    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.895724303407, Press = -0.052283832146442
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  209000   -16026.903   -16026.903   -16102.006   -16102.006    290.65597    290.65597    36180.049    36180.049    593.62703    593.62703 
  210000   -16023.196   -16023.196   -16099.363   -16099.363    294.77651    294.77651    36180.235    36180.235    829.18019    829.18019 
Loop time of 97.7683 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.158 hours/ns, 10.228 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    | 97.274     | 97.274     | 97.274     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074497   | 0.074497   | 0.074497   |   0.0 |  0.08
Output  | 0.00015309 | 0.00015309 | 0.00015309 |   0.0 |  0.00
Modify  | 0.36266    | 0.36266    | 0.36266    |   0.0 |  0.37
Other   |            | 0.05711    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.90980810897, Press = -0.188826893755092
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  210000   -16023.196   -16023.196   -16099.363   -16099.363    294.77651    294.77651    36180.235    36180.235    829.18019    829.18019 
  211000    -16027.18    -16027.18   -16103.087   -16103.087    293.76613    293.76613    36201.982    36201.982   -677.32311   -677.32311 
Loop time of 98.3018 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.306 hours/ns, 10.173 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    | 97.804     | 97.804     | 97.804     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074402   | 0.074402   | 0.074402   |   0.0 |  0.08
Output  | 0.00015561 | 0.00015561 | 0.00015561 |   0.0 |  0.00
Modify  | 0.36515    | 0.36515    | 0.36515    |   0.0 |  0.37
Other   |            | 0.05779    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.915395223295, Press = 0.0054657371703636
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  211000    -16027.18    -16027.18   -16103.087   -16103.087    293.76613    293.76613    36201.982    36201.982   -677.32311   -677.32311 
  212000   -16025.492   -16025.492    -16101.04    -16101.04    292.38164    292.38164    36193.864    36193.864   -70.312137   -70.312137 
Loop time of 98.4082 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.336 hours/ns, 10.162 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    | 97.909     | 97.909     | 97.909     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074855   | 0.074855   | 0.074855   |   0.0 |  0.08
Output  | 0.00015513 | 0.00015513 | 0.00015513 |   0.0 |  0.00
Modify  | 0.36723    | 0.36723    | 0.36723    |   0.0 |  0.37
Other   |            | 0.05736    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.923486120177, Press = -0.0146645369080823
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  212000   -16025.492   -16025.492    -16101.04    -16101.04    292.38164    292.38164    36193.864    36193.864   -70.312137   -70.312137 
  213000   -16028.757   -16028.757   -16102.542   -16102.542    285.55622    285.55622    36204.912    36204.912    -837.7977    -837.7977 
Loop time of 97.1132 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.890 ns/day, 26.976 hours/ns, 10.297 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    | 96.618     | 96.618     | 96.618     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07435    | 0.07435    | 0.07435    |   0.0 |  0.08
Output  | 0.00015347 | 0.00015347 | 0.00015347 |   0.0 |  0.00
Modify  | 0.36293    | 0.36293    | 0.36293    |   0.0 |  0.37
Other   |            | 0.05747    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.918348599567, Press = 0.0592612831316706
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  213000   -16028.757   -16028.757   -16102.542   -16102.542    285.55622    285.55622    36204.912    36204.912    -837.7977    -837.7977 
  214000   -16026.063   -16026.063   -16102.332   -16102.332    295.16946    295.16946    36211.435    36211.435   -1009.0916   -1009.0916 
Loop time of 99.2208 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.561 hours/ns, 10.079 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.716     | 98.716     | 98.716     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075522   | 0.075522   | 0.075522   |   0.0 |  0.08
Output  | 0.0001557  | 0.0001557  | 0.0001557  |   0.0 |  0.00
Modify  | 0.37148    | 0.37148    | 0.37148    |   0.0 |  0.37
Other   |            | 0.05759    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.91586728322, Press = 0.00842474695422272
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  214000   -16026.063   -16026.063   -16102.332   -16102.332    295.16946    295.16946    36211.435    36211.435   -1009.0916   -1009.0916 
  215000    -16027.13    -16027.13   -16104.388   -16104.388     298.9959     298.9959    36196.686    36196.686   -367.14579   -367.14579 
Loop time of 96.5799 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.828 hours/ns, 10.354 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    | 96.092     | 96.092     | 96.092     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073641   | 0.073641   | 0.073641   |   0.0 |  0.08
Output  | 0.00015566 | 0.00015566 | 0.00015566 |   0.0 |  0.00
Modify  | 0.35715    | 0.35715    | 0.35715    |   0.0 |  0.37
Other   |            | 0.05681    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.919891877419, Press = -0.0191903407641871
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  215000    -16027.13    -16027.13   -16104.388   -16104.388     298.9959     298.9959    36196.686    36196.686   -367.14579   -367.14579 
  216000   -16025.669   -16025.669    -16100.29    -16100.29    288.78885    288.78885    36190.279    36190.279    286.68355    286.68355 
Loop time of 99.7156 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.866 ns/day, 27.699 hours/ns, 10.029 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.206     | 99.206     | 99.206     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076307   | 0.076307   | 0.076307   |   0.0 |  0.08
Output  | 0.00019126 | 0.00019126 | 0.00019126 |   0.0 |  0.00
Modify  | 0.3754     | 0.3754     | 0.3754     |   0.0 |  0.38
Other   |            | 0.05778    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.925260207249, Press = 0.151800384749036
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  216000   -16025.669   -16025.669    -16100.29    -16100.29    288.78885    288.78885    36190.279    36190.279    286.68355    286.68355 
  217000   -16028.989   -16028.989   -16104.302   -16104.302    291.46986    291.46986    36201.106    36201.106   -734.36518   -734.36518 
Loop time of 96.5646 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.823 hours/ns, 10.356 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    | 96.077     | 96.077     | 96.077     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073612   | 0.073612   | 0.073612   |   0.0 |  0.08
Output  | 0.00015696 | 0.00015696 | 0.00015696 |   0.0 |  0.00
Modify  | 0.3575     | 0.3575     | 0.3575     |   0.0 |  0.37
Other   |            | 0.05646    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.920676870997, Press = 0.179457832913024
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  217000   -16028.989   -16028.989   -16104.302   -16104.302    291.46986    291.46986    36201.106    36201.106   -734.36518   -734.36518 
  218000   -16020.488   -16020.488   -16098.038   -16098.038     300.1263     300.1263    36190.637    36190.637    499.99152    499.99152 
Loop time of 97.8631 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.184 hours/ns, 10.218 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    | 97.365     | 97.365     | 97.365     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075018   | 0.075018   | 0.075018   |   0.0 |  0.08
Output  | 0.00015904 | 0.00015904 | 0.00015904 |   0.0 |  0.00
Modify  | 0.36506    | 0.36506    | 0.36506    |   0.0 |  0.37
Other   |            | 0.05749    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.930521820218, Press = 0.254400777455782
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  218000   -16020.488   -16020.488   -16098.038   -16098.038     300.1263     300.1263    36190.637    36190.637    499.99152    499.99152 
  219000   -16027.578   -16027.578    -16104.16    -16104.16    296.37927    296.37927    36220.219    36220.219    -1634.366    -1634.366 
Loop time of 99.7422 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.866 ns/day, 27.706 hours/ns, 10.026 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.235     | 99.235     | 99.235     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075293   | 0.075293   | 0.075293   |   0.0 |  0.08
Output  | 0.00015634 | 0.00015634 | 0.00015634 |   0.0 |  0.00
Modify  | 0.37343    | 0.37343    | 0.37343    |   0.0 |  0.37
Other   |            | 0.05828    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.940879981366, Press = 0.41880054269775
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  219000   -16027.578   -16027.578    -16104.16    -16104.16    296.37927    296.37927    36220.219    36220.219    -1634.366    -1634.366 
  220000   -16028.524   -16028.524   -16103.862   -16103.862    291.56727    291.56727    36197.753    36197.753    -441.6576    -441.6576 
Loop time of 101.046 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.855 ns/day, 28.068 hours/ns, 9.896 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.53     | 100.53     | 100.53     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07679    | 0.07679    | 0.07679    |   0.0 |  0.08
Output  | 0.00015606 | 0.00015606 | 0.00015606 |   0.0 |  0.00
Modify  | 0.38344    | 0.38344    | 0.38344    |   0.0 |  0.38
Other   |            | 0.05954    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.940812961809, Press = 0.331980858616434
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  220000   -16028.524   -16028.524   -16103.862   -16103.862    291.56727    291.56727    36197.753    36197.753    -441.6576    -441.6576 
  221000    -16025.89    -16025.89    -16102.67    -16102.67    297.14607    297.14607    36223.742    36223.742   -1648.3973   -1648.3973 
Loop time of 97.6718 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.885 ns/day, 27.131 hours/ns, 10.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    | 97.174     | 97.174     | 97.174     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074442   | 0.074442   | 0.074442   |   0.0 |  0.08
Output  | 0.0001568  | 0.0001568  | 0.0001568  |   0.0 |  0.00
Modify  | 0.36538    | 0.36538    | 0.36538    |   0.0 |  0.37
Other   |            | 0.0579     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115994.0 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.941410307546, Press = 0.297130626865853
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  221000    -16025.89    -16025.89    -16102.67    -16102.67    297.14607    297.14607    36223.742    36223.742   -1648.3973   -1648.3973 
  222000   -16033.202   -16033.202   -16105.253   -16105.253      278.841      278.841    36188.533    36188.533   -150.63206   -150.63206 
Loop time of 100.758 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.857 ns/day, 27.988 hours/ns, 9.925 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.24     | 100.24     | 100.24     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077099   | 0.077099   | 0.077099   |   0.0 |  0.08
Output  | 0.00015441 | 0.00015441 | 0.00015441 |   0.0 |  0.00
Modify  | 0.38199    | 0.38199    | 0.38199    |   0.0 |  0.38
Other   |            | 0.0591     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.940926253856, Press = 0.0993068524051706
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  222000   -16033.202   -16033.202   -16105.253   -16105.253      278.841      278.841    36188.533    36188.533   -150.63206   -150.63206 
  223000   -16027.451   -16027.451   -16104.001   -16104.001    296.25688    296.25688     36194.86     36194.86   -319.71145   -319.71145 
Loop time of 99.4096 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.614 hours/ns, 10.059 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    | 98.901     | 98.901     | 98.901     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075947   | 0.075947   | 0.075947   |   0.0 |  0.08
Output  | 0.00015361 | 0.00015361 | 0.00015361 |   0.0 |  0.00
Modify  | 0.37488    | 0.37488    | 0.37488    |   0.0 |  0.38
Other   |            | 0.05793    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.926553205488, Press = -0.00673742891481654
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  223000   -16027.451   -16027.451   -16104.001   -16104.001    296.25688    296.25688     36194.86     36194.86   -319.71145   -319.71145 
  224000   -16024.545   -16024.545   -16101.042   -16101.042    296.05357    296.05357    36153.161    36153.161    2293.3912    2293.3912 
Loop time of 98.2689 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.297 hours/ns, 10.176 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    | 97.768     | 97.768     | 97.768     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075921   | 0.075921   | 0.075921   |   0.0 |  0.08
Output  | 0.00018707 | 0.00018707 | 0.00018707 |   0.0 |  0.00
Modify  | 0.36697    | 0.36697    | 0.36697    |   0.0 |  0.37
Other   |            | 0.05735    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.933532569463, Press = 0.116875310790142
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  224000   -16024.545   -16024.545   -16101.042   -16101.042    296.05357    296.05357    36153.161    36153.161    2293.3912    2293.3912 
  225000    -16026.19    -16026.19   -16102.497   -16102.497    295.31664    295.31664    36153.263    36153.263    2067.2571    2067.2571 
Loop time of 99.6642 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.867 ns/day, 27.684 hours/ns, 10.034 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.156     | 99.156     | 99.156     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075947   | 0.075947   | 0.075947   |   0.0 |  0.08
Output  | 0.00015595 | 0.00015595 | 0.00015595 |   0.0 |  0.00
Modify  | 0.37416    | 0.37416    | 0.37416    |   0.0 |  0.38
Other   |            | 0.05797    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.929764930215, Press = 0.14428926459166
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  225000    -16026.19    -16026.19   -16102.497   -16102.497    295.31664    295.31664    36153.263    36153.263    2067.2571    2067.2571 
  226000   -16028.796   -16028.796   -16104.981   -16104.981    294.84579    294.84579    36171.749    36171.749    866.59298    866.59298 
Loop time of 99.3531 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.598 hours/ns, 10.065 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    | 98.851     | 98.851     | 98.851     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075083   | 0.075083   | 0.075083   |   0.0 |  0.08
Output  | 0.00015622 | 0.00015622 | 0.00015622 |   0.0 |  0.00
Modify  | 0.36939    | 0.36939    | 0.36939    |   0.0 |  0.37
Other   |            | 0.05722    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.926015579331, Press = 0.127444049092682
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  226000   -16028.796   -16028.796   -16104.981   -16104.981    294.84579    294.84579    36171.749    36171.749    866.59298    866.59298 
  227000   -16024.479   -16024.479   -16100.813   -16100.813    295.41826    295.41826     36178.56     36178.56    944.31431    944.31431 
Loop time of 98.0425 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.234 hours/ns, 10.200 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    | 97.543     | 97.543     | 97.543     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07523    | 0.07523    | 0.07523    |   0.0 |  0.08
Output  | 0.00024357 | 0.00024357 | 0.00024357 |   0.0 |  0.00
Modify  | 0.36663    | 0.36663    | 0.36663    |   0.0 |  0.37
Other   |            | 0.05786    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.935224934337, Press = 0.0752696615361036
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  227000   -16024.479   -16024.479   -16100.813   -16100.813    295.41826    295.41826     36178.56     36178.56    944.31431    944.31431 
  228000   -16027.185   -16027.185   -16102.975   -16102.975     293.3169     293.3169    36181.231    36181.231    547.02263    547.02263 
Loop time of 104.052 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.903 hours/ns, 9.611 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.52     | 103.52     | 103.52     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078179   | 0.078179   | 0.078179   |   0.0 |  0.08
Output  | 0.00019016 | 0.00019016 | 0.00019016 |   0.0 |  0.00
Modify  | 0.39407    | 0.39407    | 0.39407    |   0.0 |  0.38
Other   |            | 0.05936    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.943804797604, Press = 0.0995758259023895
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  228000   -16027.185   -16027.185   -16102.975   -16102.975     293.3169     293.3169    36181.231    36181.231    547.02263    547.02263 
  229000    -16026.49    -16026.49   -16101.208   -16101.208    289.16861    289.16861    36168.688    36168.688    1342.7303    1342.7303 
Loop time of 99.3588 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.600 hours/ns, 10.065 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    | 98.856     | 98.856     | 98.856     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075476   | 0.075476   | 0.075476   |   0.0 |  0.08
Output  | 0.00015746 | 0.00015746 | 0.00015746 |   0.0 |  0.00
Modify  | 0.36908    | 0.36908    | 0.36908    |   0.0 |  0.37
Other   |            | 0.05759    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.947026595747, Press = 0.171010911161775
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  229000    -16026.49    -16026.49   -16101.208   -16101.208    289.16861    289.16861    36168.688    36168.688    1342.7303    1342.7303 
  230000   -16023.169   -16023.169   -16097.408   -16097.408    287.31312    287.31312    36129.702    36129.702    3697.3293    3697.3293 
Loop time of 97.0527 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.890 ns/day, 26.959 hours/ns, 10.304 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    | 96.56      | 96.56      | 96.56      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074519   | 0.074519   | 0.074519   |   0.0 |  0.08
Output  | 0.00015453 | 0.00015453 | 0.00015453 |   0.0 |  0.00
Modify  | 0.36054    | 0.36054    | 0.36054    |   0.0 |  0.37
Other   |            | 0.05712    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.947799597446, Press = 0.21456453883127
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  230000   -16023.169   -16023.169   -16097.408   -16097.408    287.31312    287.31312    36129.702    36129.702    3697.3293    3697.3293 
  231000   -16027.542   -16027.542   -16104.942   -16104.942    299.54343    299.54343    36162.858    36162.858    1244.6113    1244.6113 
Loop time of 97.9054 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.196 hours/ns, 10.214 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    | 97.408     | 97.408     | 97.408     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074746   | 0.074746   | 0.074746   |   0.0 |  0.08
Output  | 0.00015517 | 0.00015517 | 0.00015517 |   0.0 |  0.00
Modify  | 0.36541    | 0.36541    | 0.36541    |   0.0 |  0.37
Other   |            | 0.0572     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0