# 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.303897500038147*${_u_distance}
variable latticeconst_converted equal 3.303897500038147*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.30389750003815
Lattice spacing in x,y,z = 3.3038975 3.3038975 3.3038975
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.038975 33.038975 33.038975)
  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.038975 33.038975 33.038975)
  create_atoms CPU = 0.001 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 EAM_Dynamo_ChenFangLiu_2019_WTa__MO_645806019892_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 36064.4817714662    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 36064.4817714662/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 36064.4817714662/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 36064.4817714662/(1*1*${_u_distance})
variable      V0_metal equal 36064.4817714662/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 36064.4817714662*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 36064.4817714662 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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_645806019892_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 = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -16129.292   -16129.292   -16199.872   -16199.872       273.15       273.15    36064.482    36064.482    2090.3602    2090.3602 
    1000   -16059.295   -16059.295   -16128.759   -16128.759    268.83655    268.83655    36382.604    36382.604    719.68886    719.68886 
Loop time of 10.656 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.108 ns/day, 2.960 hours/ns, 93.844 timesteps/s
94.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    | 10.434     | 10.434     | 10.434     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035869   | 0.035869   | 0.035869   |   0.0 |  0.34
Output  | 0.00026787 | 0.00026787 | 0.00026787 |   0.0 |  0.00
Modify  | 0.16175    | 0.16175    | 0.16175    |   0.0 |  1.52
Other   |            | 0.02444    |            |       |  0.23

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -16059.295   -16059.295   -16128.759   -16128.759    268.83655    268.83655    36382.604    36382.604    719.68886    719.68886 
    2000    -16057.33    -16057.33   -16126.239   -16126.239    266.68543    266.68543    36459.213    36459.213    -2635.132    -2635.132 
Loop time of 10.008 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.633 ns/day, 2.780 hours/ns, 99.920 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.8083     | 9.8083     | 9.8083     |   0.0 | 98.00
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.033976   | 0.033976   | 0.033976   |   0.0 |  0.34
Output  | 0.00012291 | 0.00012291 | 0.00012291 |   0.0 |  0.00
Modify  | 0.14431    | 0.14431    | 0.14431    |   0.0 |  1.44
Other   |            | 0.02131    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223326.0 ave      223326 max      223326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223326
Ave neighs/atom = 111.66300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -16057.33    -16057.33   -16126.239   -16126.239    266.68543    266.68543    36459.213    36459.213    -2635.132    -2635.132 
    3000   -16061.844   -16061.844   -16132.746   -16132.746     274.3961     274.3961    36355.107    36355.107    1310.6725    1310.6725 
Loop time of 9.85668 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.766 ns/day, 2.738 hours/ns, 101.454 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6656     | 9.6656     | 9.6656     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032817   | 0.032817   | 0.032817   |   0.0 |  0.33
Output  | 0.00012593 | 0.00012593 | 0.00012593 |   0.0 |  0.00
Modify  | 0.13905    | 0.13905    | 0.13905    |   0.0 |  1.41
Other   |            | 0.01913    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223154.0 ave      223154 max      223154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223154
Ave neighs/atom = 111.57700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -16061.844   -16061.844   -16132.746   -16132.746     274.3961     274.3961    36355.107    36355.107    1310.6725    1310.6725 
    4000   -16055.502   -16055.502   -16129.448   -16129.448    286.18057    286.18057     36398.86     36398.86   -261.88432   -261.88432 
Loop time of 9.86377 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.759 ns/day, 2.740 hours/ns, 101.381 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6728     | 9.6728     | 9.6728     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032997   | 0.032997   | 0.032997   |   0.0 |  0.33
Output  | 0.00012239 | 0.00012239 | 0.00012239 |   0.0 |  0.00
Modify  | 0.13878    | 0.13878    | 0.13878    |   0.0 |  1.41
Other   |            | 0.0191     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223510.0 ave      223510 max      223510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223510
Ave neighs/atom = 111.75500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -16055.502   -16055.502   -16129.448   -16129.448    286.18057    286.18057     36398.86     36398.86   -261.88432   -261.88432 
    5000   -16061.472   -16061.472   -16130.223   -16130.223    266.07411    266.07411    36358.885    36358.885    1633.3683    1633.3683 
Loop time of 9.85324 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.769 ns/day, 2.737 hours/ns, 101.489 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6616     | 9.6616     | 9.6616     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032954   | 0.032954   | 0.032954   |   0.0 |  0.33
Output  | 9.3155e-05 | 9.3155e-05 | 9.3155e-05 |   0.0 |  0.00
Modify  | 0.13947    | 0.13947    | 0.13947    |   0.0 |  1.42
Other   |            | 0.01912    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223402.0 ave      223402 max      223402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223402
Ave neighs/atom = 111.70100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 265.740722624185, Press = -216.490591758876
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -16061.472   -16061.472   -16130.223   -16130.223    266.07411    266.07411    36358.885    36358.885    1633.3683    1633.3683 
    6000   -16058.252   -16058.252   -16129.154   -16129.154    274.39761    274.39761    36395.359    36395.359    191.44533    191.44533 
Loop time of 9.86876 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.755 ns/day, 2.741 hours/ns, 101.330 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6732     | 9.6732     | 9.6732     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032761   | 0.032761   | 0.032761   |   0.0 |  0.33
Output  | 6.066e-05  | 6.066e-05  | 6.066e-05  |   0.0 |  0.00
Modify  | 0.14364    | 0.14364    | 0.14364    |   0.0 |  1.46
Other   |            | 0.01909    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223406.0 ave      223406 max      223406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223406
Ave neighs/atom = 111.70300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.883925568116, Press = -62.6976689226873
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -16058.252   -16058.252   -16129.154   -16129.154    274.39761    274.39761    36395.359    36395.359    191.44533    191.44533 
    7000   -16058.813   -16058.813    -16130.37    -16130.37    276.93286    276.93286    36357.677    36357.677    2047.7015    2047.7015 
Loop time of 9.88919 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.737 ns/day, 2.747 hours/ns, 101.120 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6936     | 9.6936     | 9.6936     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032836   | 0.032836   | 0.032836   |   0.0 |  0.33
Output  | 6.2338e-05 | 6.2338e-05 | 6.2338e-05 |   0.0 |  0.00
Modify  | 0.14358    | 0.14358    | 0.14358    |   0.0 |  1.45
Other   |            | 0.01914    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223322.0 ave      223322 max      223322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223322
Ave neighs/atom = 111.66100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.320527341269, Press = -14.2124009224742
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -16058.813   -16058.813    -16130.37    -16130.37    276.93286    276.93286    36357.677    36357.677    2047.7015    2047.7015 
    8000   -16058.097   -16058.097   -16130.201   -16130.201      279.051      279.051    36404.409    36404.409   -386.77824   -386.77824 
Loop time of 9.86819 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.755 ns/day, 2.741 hours/ns, 101.336 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6718     | 9.6718     | 9.6718     |   0.0 | 98.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032901   | 0.032901   | 0.032901   |   0.0 |  0.33
Output  | 9.1797e-05 | 9.1797e-05 | 9.1797e-05 |   0.0 |  0.00
Modify  | 0.144      | 0.144      | 0.144      |   0.0 |  1.46
Other   |            | 0.01935    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223452.0 ave      223452 max      223452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223452
Ave neighs/atom = 111.72600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.457666862197, Press = -1.82757983253021
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -16058.097   -16058.097   -16130.201   -16130.201      279.051      279.051    36404.409    36404.409   -386.77824   -386.77824 
    9000   -16057.789   -16057.789   -16129.049   -16129.049    275.78665    275.78665    36401.245    36401.245   -142.72636   -142.72636 
Loop time of 9.87933 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.746 ns/day, 2.744 hours/ns, 101.221 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6832     | 9.6832     | 9.6832     |   0.0 | 98.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03289    | 0.03289    | 0.03289    |   0.0 |  0.33
Output  | 6.3064e-05 | 6.3064e-05 | 6.3064e-05 |   0.0 |  0.00
Modify  | 0.14383    | 0.14383    | 0.14383    |   0.0 |  1.46
Other   |            | 0.01932    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223394.0 ave      223394 max      223394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223394
Ave neighs/atom = 111.69700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.155644410604, Press = -15.182001866253
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -16057.789   -16057.789   -16129.049   -16129.049    275.78665    275.78665    36401.245    36401.245   -142.72636   -142.72636 
   10000   -16058.036   -16058.036   -16128.774   -16128.774    273.76485    273.76485    36396.011    36396.011    51.500862    51.500862 
Loop time of 9.85791 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.765 ns/day, 2.738 hours/ns, 101.441 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6624     | 9.6624     | 9.6624     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032744   | 0.032744   | 0.032744   |   0.0 |  0.33
Output  | 6.1719e-05 | 6.1719e-05 | 6.1719e-05 |   0.0 |  0.00
Modify  | 0.1436     | 0.1436     | 0.1436     |   0.0 |  1.46
Other   |            | 0.01912    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223382.0 ave      223382 max      223382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223382
Ave neighs/atom = 111.69100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.193136563387, Press = -0.318093081613866
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -16058.036   -16058.036   -16128.774   -16128.774    273.76485    273.76485    36396.011    36396.011    51.500862    51.500862 
   11000   -16060.223   -16060.223   -16130.312   -16130.312    271.25442    271.25442    36435.973    36435.973   -2596.9285   -2596.9285 
Loop time of 9.88087 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.744 ns/day, 2.745 hours/ns, 101.206 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.685      | 9.685      | 9.685      |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032736   | 0.032736   | 0.032736   |   0.0 |  0.33
Output  | 6.2403e-05 | 6.2403e-05 | 6.2403e-05 |   0.0 |  0.00
Modify  | 0.14386    | 0.14386    | 0.14386    |   0.0 |  1.46
Other   |            | 0.01919    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223344.0 ave      223344 max      223344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223344
Ave neighs/atom = 111.67200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.232158832591, Press = -17.8116311898156
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -16060.223   -16060.223   -16130.312   -16130.312    271.25442    271.25442    36435.973    36435.973   -2596.9285   -2596.9285 
   12000   -16060.229   -16060.229   -16129.548   -16129.548    268.27457    268.27457    36371.707    36371.707    1194.0511    1194.0511 
Loop time of 9.88084 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.744 ns/day, 2.745 hours/ns, 101.206 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6848     | 9.6848     | 9.6848     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032756   | 0.032756   | 0.032756   |   0.0 |  0.33
Output  | 7.9587e-05 | 7.9587e-05 | 7.9587e-05 |   0.0 |  0.00
Modify  | 0.14395    | 0.14395    | 0.14395    |   0.0 |  1.46
Other   |            | 0.01928    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223298.0 ave      223298 max      223298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223298
Ave neighs/atom = 111.64900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.480981350649, Press = -2.54257786317682
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -16060.229   -16060.229   -16129.548   -16129.548    268.27457    268.27457    36371.707    36371.707    1194.0511    1194.0511 
   13000   -16060.129   -16060.129   -16129.773   -16129.773    269.52983    269.52983    36373.141    36373.141    989.41938    989.41938 
Loop time of 9.87433 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.750 ns/day, 2.743 hours/ns, 101.273 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6787     | 9.6787     | 9.6787     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032748   | 0.032748   | 0.032748   |   0.0 |  0.33
Output  | 6.3063e-05 | 6.3063e-05 | 6.3063e-05 |   0.0 |  0.00
Modify  | 0.14366    | 0.14366    | 0.14366    |   0.0 |  1.45
Other   |            | 0.01917    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223402.0 ave      223402 max      223402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223402
Ave neighs/atom = 111.70100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.64012568212, Press = -5.27542541389704
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -16060.129   -16060.129   -16129.773   -16129.773    269.52983    269.52983    36373.141    36373.141    989.41938    989.41938 
   14000    -16061.54    -16061.54   -16130.494   -16130.494    266.85994    266.85994    36438.152    36438.152   -2639.0621   -2639.0621 
Loop time of 9.88578 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.740 ns/day, 2.746 hours/ns, 101.155 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6898     | 9.6898     | 9.6898     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032735   | 0.032735   | 0.032735   |   0.0 |  0.33
Output  | 6.3115e-05 | 6.3115e-05 | 6.3115e-05 |   0.0 |  0.00
Modify  | 0.14392    | 0.14392    | 0.14392    |   0.0 |  1.46
Other   |            | 0.01931    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223444.0 ave      223444 max      223444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223444
Ave neighs/atom = 111.72200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.448709532123, Press = -3.15086544762162
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000    -16061.54    -16061.54   -16130.494   -16130.494    266.85994    266.85994    36438.152    36438.152   -2639.0621   -2639.0621 
   15000   -16059.696   -16059.696   -16129.566   -16129.566    270.40275    270.40275    36380.703    36380.703     960.0909     960.0909 
Loop time of 9.86381 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.759 ns/day, 2.740 hours/ns, 101.381 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6682     | 9.6682     | 9.6682     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032774   | 0.032774   | 0.032774   |   0.0 |  0.33
Output  | 0.00031764 | 0.00031764 | 0.00031764 |   0.0 |  0.00
Modify  | 0.14345    | 0.14345    | 0.14345    |   0.0 |  1.45
Other   |            | 0.01908    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223424.0 ave      223424 max      223424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223424
Ave neighs/atom = 111.71200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.315439883574, Press = -4.05955055717964
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -16059.696   -16059.696   -16129.566   -16129.566    270.40275    270.40275    36380.703    36380.703     960.0909     960.0909 
   16000   -16058.667   -16058.667   -16128.822   -16128.822    271.50673    271.50673    36418.226    36418.226   -1032.4647   -1032.4647 
Loop time of 9.86979 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.754 ns/day, 2.742 hours/ns, 101.319 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.674      | 9.674      | 9.674      |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032685   | 0.032685   | 0.032685   |   0.0 |  0.33
Output  | 6.6625e-05 | 6.6625e-05 | 6.6625e-05 |   0.0 |  0.00
Modify  | 0.14381    | 0.14381    | 0.14381    |   0.0 |  1.46
Other   |            | 0.01918    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223342.0 ave      223342 max      223342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223342
Ave neighs/atom = 111.67100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.298656073282, Press = -6.50336150080675
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -16058.667   -16058.667   -16128.822   -16128.822    271.50673    271.50673    36418.226    36418.226   -1032.4647   -1032.4647 
   17000   -16061.008   -16061.008    -16130.84    -16130.84    270.25871    270.25871    36361.615    36361.615    1693.6472    1693.6472 
Loop time of 9.87322 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.751 ns/day, 2.743 hours/ns, 101.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    | 9.6777     | 9.6777     | 9.6777     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032803   | 0.032803   | 0.032803   |   0.0 |  0.33
Output  | 6.3422e-05 | 6.3422e-05 | 6.3422e-05 |   0.0 |  0.00
Modify  | 0.1436     | 0.1436     | 0.1436     |   0.0 |  1.45
Other   |            | 0.0191     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223370.0 ave      223370 max      223370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223370
Ave neighs/atom = 111.68500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.248610307433, Press = -2.86291078627474
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -16061.008   -16061.008    -16130.84    -16130.84    270.25871    270.25871    36361.615    36361.615    1693.6472    1693.6472 
   18000   -16058.821   -16058.821   -16131.201   -16131.201    280.11535    280.11535    36381.239    36381.239    682.57826    682.57826 
Loop time of 9.89043 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.736 ns/day, 2.747 hours/ns, 101.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    | 9.6946     | 9.6946     | 9.6946     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032697   | 0.032697   | 0.032697   |   0.0 |  0.33
Output  | 6.333e-05  | 6.333e-05  | 6.333e-05  |   0.0 |  0.00
Modify  | 0.1438     | 0.1438     | 0.1438     |   0.0 |  1.45
Other   |            | 0.01924    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223448.0 ave      223448 max      223448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223448
Ave neighs/atom = 111.72400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.353069252632, Press = -5.87832300933872
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -16058.821   -16058.821   -16131.201   -16131.201    280.11535    280.11535    36381.239    36381.239    682.57826    682.57826 
   19000    -16059.13    -16059.13    -16129.27    -16129.27    271.44949    271.44949    36428.403    36428.403   -1674.1907   -1674.1907 
Loop time of 9.88979 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.736 ns/day, 2.747 hours/ns, 101.114 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.694      | 9.694      | 9.694      |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032774   | 0.032774   | 0.032774   |   0.0 |  0.33
Output  | 9.3925e-05 | 9.3925e-05 | 9.3925e-05 |   0.0 |  0.00
Modify  | 0.14365    | 0.14365    | 0.14365    |   0.0 |  1.45
Other   |            | 0.01927    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223500.0 ave      223500 max      223500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223500
Ave neighs/atom = 111.75000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.441300298152, Press = -1.97647266230653
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -16059.13    -16059.13    -16129.27    -16129.27    271.44949    271.44949    36428.403    36428.403   -1674.1907   -1674.1907 
   20000   -16058.017   -16058.017    -16127.41    -16127.41     268.5603     268.5603    36398.516    36398.516     301.0484     301.0484 
Loop time of 9.878 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.747 ns/day, 2.744 hours/ns, 101.235 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6817     | 9.6817     | 9.6817     |   0.0 | 98.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032952   | 0.032952   | 0.032952   |   0.0 |  0.33
Output  | 6.1586e-05 | 6.1586e-05 | 6.1586e-05 |   0.0 |  0.00
Modify  | 0.14395    | 0.14395    | 0.14395    |   0.0 |  1.46
Other   |            | 0.01939    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223374.0 ave      223374 max      223374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223374
Ave neighs/atom = 111.68700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.59939022547, Press = -2.83930262491944
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -16058.017   -16058.017    -16127.41    -16127.41     268.5603     268.5603    36398.516    36398.516     301.0484     301.0484 
   21000   -16060.248   -16060.248   -16129.899   -16129.899    269.55804    269.55804    36378.505    36378.505    923.13598    923.13598 
Loop time of 9.88464 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.741 ns/day, 2.746 hours/ns, 101.167 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6886     | 9.6886     | 9.6886     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032795   | 0.032795   | 0.032795   |   0.0 |  0.33
Output  | 6.0008e-05 | 6.0008e-05 | 6.0008e-05 |   0.0 |  0.00
Modify  | 0.14391    | 0.14391    | 0.14391    |   0.0 |  1.46
Other   |            | 0.01929    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223340.0 ave      223340 max      223340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223340
Ave neighs/atom = 111.67000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.44784354348, Press = -1.6578494155569
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -16060.248   -16060.248   -16129.899   -16129.899    269.55804    269.55804    36378.505    36378.505    923.13598    923.13598 
   22000   -16058.786   -16058.786   -16130.023   -16130.023    275.69564    275.69564    36374.053    36374.053    1093.8362    1093.8362 
Loop time of 9.8614 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.761 ns/day, 2.739 hours/ns, 101.405 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6659     | 9.6659     | 9.6659     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032623   | 0.032623   | 0.032623   |   0.0 |  0.33
Output  | 6.1589e-05 | 6.1589e-05 | 6.1589e-05 |   0.0 |  0.00
Modify  | 0.14363    | 0.14363    | 0.14363    |   0.0 |  1.46
Other   |            | 0.01915    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223410.0 ave      223410 max      223410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223410
Ave neighs/atom = 111.70500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.39554841059, Press = -0.657410199241936
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -16058.786   -16058.786   -16130.023   -16130.023    275.69564    275.69564    36374.053    36374.053    1093.8362    1093.8362 
   23000   -16059.236   -16059.236   -16129.629   -16129.629    272.42696    272.42696    36415.663    36415.663   -996.69445   -996.69445 
Loop time of 9.8503 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.771 ns/day, 2.736 hours/ns, 101.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6547     | 9.6547     | 9.6547     |   0.0 | 98.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032752   | 0.032752   | 0.032752   |   0.0 |  0.33
Output  | 6.6946e-05 | 6.6946e-05 | 6.6946e-05 |   0.0 |  0.00
Modify  | 0.14363    | 0.14363    | 0.14363    |   0.0 |  1.46
Other   |            | 0.01912    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223432.0 ave      223432 max      223432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223432
Ave neighs/atom = 111.71600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.361080091843, Press = -2.31803950214152
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -16059.236   -16059.236   -16129.629   -16129.629    272.42696    272.42696    36415.663    36415.663   -996.69445   -996.69445 
   24000   -16058.964   -16058.964    -16128.66    -16128.66    269.72892    269.72892    36396.867    36396.867    -5.655516    -5.655516 
Loop time of 9.85856 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.764 ns/day, 2.738 hours/ns, 101.435 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6628     | 9.6628     | 9.6628     |   0.0 | 98.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032778   | 0.032778   | 0.032778   |   0.0 |  0.33
Output  | 6.1908e-05 | 6.1908e-05 | 6.1908e-05 |   0.0 |  0.00
Modify  | 0.14376    | 0.14376    | 0.14376    |   0.0 |  1.46
Other   |            | 0.01914    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223352.0 ave      223352 max      223352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223352
Ave neighs/atom = 111.67600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.376709256347, Press = -2.60281171099609
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -16058.964   -16058.964    -16128.66    -16128.66    269.72892    269.72892    36396.867    36396.867    -5.655516    -5.655516 
   25000   -16061.376   -16061.376   -16131.016   -16131.016    269.51402    269.51402    36374.906    36374.906    627.27619    627.27619 
Loop time of 9.87902 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.746 ns/day, 2.744 hours/ns, 101.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    | 9.6834     | 9.6834     | 9.6834     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032747   | 0.032747   | 0.032747   |   0.0 |  0.33
Output  | 9.5194e-05 | 9.5194e-05 | 9.5194e-05 |   0.0 |  0.00
Modify  | 0.1436     | 0.1436     | 0.1436     |   0.0 |  1.45
Other   |            | 0.01916    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223260.0 ave      223260 max      223260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223260
Ave neighs/atom = 111.63000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.333404644139, Press = -1.50824450369314
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -16061.376   -16061.376   -16131.016   -16131.016    269.51402    269.51402    36374.906    36374.906    627.27619    627.27619 
   26000   -16052.928   -16052.928   -16127.142   -16127.142    287.21476    287.21476    36453.347    36453.347   -2154.9308   -2154.9308 
Loop time of 9.86991 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.754 ns/day, 2.742 hours/ns, 101.318 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6747     | 9.6747     | 9.6747     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032661   | 0.032661   | 0.032661   |   0.0 |  0.33
Output  | 6.3856e-05 | 6.3856e-05 | 6.3856e-05 |   0.0 |  0.00
Modify  | 0.14342    | 0.14342    | 0.14342    |   0.0 |  1.45
Other   |            | 0.0191     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223412.0 ave      223412 max      223412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223412
Ave neighs/atom = 111.70600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.341560914874, Press = -3.34933539672294
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -16052.928   -16052.928   -16127.142   -16127.142    287.21476    287.21476    36453.347    36453.347   -2154.9308   -2154.9308 
   27000     -16059.6     -16059.6   -16128.585   -16128.585    266.98149    266.98149     36354.77     36354.77    2620.2074    2620.2074 
Loop time of 9.87731 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.747 ns/day, 2.744 hours/ns, 101.242 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6816     | 9.6816     | 9.6816     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03288    | 0.03288    | 0.03288    |   0.0 |  0.33
Output  | 6.085e-05  | 6.085e-05  | 6.085e-05  |   0.0 |  0.00
Modify  | 0.14358    | 0.14358    | 0.14358    |   0.0 |  1.45
Other   |            | 0.01916    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223220.0 ave      223220 max      223220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223220
Ave neighs/atom = 111.61000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.460388726534, Press = -1.45963567206302
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000     -16059.6     -16059.6   -16128.585   -16128.585    266.98149    266.98149     36354.77     36354.77    2620.2074    2620.2074 
   28000   -16055.424   -16055.424   -16128.328   -16128.328    282.14613    282.14613    36408.516    36408.516   -322.01757   -322.01757 
Loop time of 9.85106 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.771 ns/day, 2.736 hours/ns, 101.512 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6556     | 9.6556     | 9.6556     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032754   | 0.032754   | 0.032754   |   0.0 |  0.33
Output  | 6.2943e-05 | 6.2943e-05 | 6.2943e-05 |   0.0 |  0.00
Modify  | 0.14349    | 0.14349    | 0.14349    |   0.0 |  1.46
Other   |            | 0.01912    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223416.0 ave      223416 max      223416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223416
Ave neighs/atom = 111.70800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.522900737198, Press = -1.96229378255666
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -16055.424   -16055.424   -16128.328   -16128.328    282.14613    282.14613    36408.516    36408.516   -322.01757   -322.01757 
   29000   -16059.619   -16059.619   -16131.183   -16131.183    276.95906    276.95906    36346.436    36346.436    2266.1296    2266.1296 
Loop time of 9.85189 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.770 ns/day, 2.737 hours/ns, 101.503 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6566     | 9.6566     | 9.6566     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032629   | 0.032629   | 0.032629   |   0.0 |  0.33
Output  | 6.1797e-05 | 6.1797e-05 | 6.1797e-05 |   0.0 |  0.00
Modify  | 0.14348    | 0.14348    | 0.14348    |   0.0 |  1.46
Other   |            | 0.01911    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223256.0 ave      223256 max      223256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223256
Ave neighs/atom = 111.62800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.625737136516, Press = -2.53219063197836
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -16059.619   -16059.619   -16131.183   -16131.183    276.95906    276.95906    36346.436    36346.436    2266.1296    2266.1296 
   30000   -16056.709   -16056.709   -16129.305   -16129.305    280.95237    280.95237    36433.226    36433.226   -1898.9811   -1898.9811 
Loop time of 9.86398 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.759 ns/day, 2.740 hours/ns, 101.379 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6684     | 9.6684     | 9.6684     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032782   | 0.032782   | 0.032782   |   0.0 |  0.33
Output  | 6.2883e-05 | 6.2883e-05 | 6.2883e-05 |   0.0 |  0.00
Modify  | 0.14357    | 0.14357    | 0.14357    |   0.0 |  1.46
Other   |            | 0.01918    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223422.0 ave      223422 max      223422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223422
Ave neighs/atom = 111.71100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.634296205193, Press = -3.74793080489701
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -16056.709   -16056.709   -16129.305   -16129.305    280.95237    280.95237    36433.226    36433.226   -1898.9811   -1898.9811 
   31000   -16061.028   -16061.028   -16129.185   -16129.185    263.77472    263.77472    36375.024    36375.024    1295.7181    1295.7181 
Loop time of 9.86664 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.757 ns/day, 2.741 hours/ns, 101.352 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6711     | 9.6711     | 9.6711     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032795   | 0.032795   | 0.032795   |   0.0 |  0.33
Output  | 9.0529e-05 | 9.0529e-05 | 9.0529e-05 |   0.0 |  0.00
Modify  | 0.1435     | 0.1435     | 0.1435     |   0.0 |  1.45
Other   |            | 0.01915    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223242.0 ave      223242 max      223242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223242
Ave neighs/atom = 111.62100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.643572023507, Press = -0.603288358807988
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -16061.028   -16061.028   -16129.185   -16129.185    263.77472    263.77472    36375.024    36375.024    1295.7181    1295.7181 
   32000    -16054.28    -16054.28   -16125.764   -16125.764    276.65283    276.65283    36432.141    36432.141   -1233.9011   -1233.9011 
Loop time of 9.8723 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.752 ns/day, 2.742 hours/ns, 101.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    | 9.6768     | 9.6768     | 9.6768     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032801   | 0.032801   | 0.032801   |   0.0 |  0.33
Output  | 6.0819e-05 | 6.0819e-05 | 6.0819e-05 |   0.0 |  0.00
Modify  | 0.14348    | 0.14348    | 0.14348    |   0.0 |  1.45
Other   |            | 0.01915    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223400.0 ave      223400 max      223400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223400
Ave neighs/atom = 111.70000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.647386387141, Press = -2.94978754746195
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    -16054.28    -16054.28   -16125.764   -16125.764    276.65283    276.65283    36432.141    36432.141   -1233.9011   -1233.9011 
   33000   -16060.444   -16060.444   -16129.322   -16129.322    266.56324    266.56324    36386.541    36386.541    398.39256    398.39256 
Loop time of 9.86125 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.762 ns/day, 2.739 hours/ns, 101.407 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6659     | 9.6659     | 9.6659     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032783   | 0.032783   | 0.032783   |   0.0 |  0.33
Output  | 6.195e-05  | 6.195e-05  | 6.195e-05  |   0.0 |  0.00
Modify  | 0.14343    | 0.14343    | 0.14343    |   0.0 |  1.45
Other   |            | 0.0191     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223196.0 ave      223196 max      223196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223196
Ave neighs/atom = 111.59800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.699648665063, Press = -1.8577306091523
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -16060.444   -16060.444   -16129.322   -16129.322    266.56324    266.56324    36386.541    36386.541    398.39256    398.39256 
   34000   -16058.945   -16058.945    -16129.89    -16129.89    274.56636    274.56636    36378.183    36378.183    1086.8892    1086.8892 
Loop time of 9.87317 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.751 ns/day, 2.743 hours/ns, 101.285 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6779     | 9.6779     | 9.6779     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032736   | 0.032736   | 0.032736   |   0.0 |  0.33
Output  | 6.1697e-05 | 6.1697e-05 | 6.1697e-05 |   0.0 |  0.00
Modify  | 0.1433     | 0.1433     | 0.1433     |   0.0 |  1.45
Other   |            | 0.01914    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223356.0 ave      223356 max      223356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223356
Ave neighs/atom = 111.67800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.667974678278, Press = 0.195504258339587
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -16058.945   -16058.945    -16129.89    -16129.89    274.56636    274.56636    36378.183    36378.183    1086.8892    1086.8892 
   35000   -16056.301   -16056.301   -16127.971   -16127.971     277.3703     277.3703    36449.219    36449.219   -2251.7306   -2251.7306 
Loop time of 9.86224 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.761 ns/day, 2.740 hours/ns, 101.397 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6672     | 9.6672     | 9.6672     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032695   | 0.032695   | 0.032695   |   0.0 |  0.33
Output  | 6.2442e-05 | 6.2442e-05 | 6.2442e-05 |   0.0 |  0.00
Modify  | 0.14324    | 0.14324    | 0.14324    |   0.0 |  1.45
Other   |            | 0.01909    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223354.0 ave      223354 max      223354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223354
Ave neighs/atom = 111.67700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.601450985529, Press = -1.71544104049422
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -16056.301   -16056.301   -16127.971   -16127.971     277.3703     277.3703    36449.219    36449.219   -2251.7306   -2251.7306 
   36000   -16059.446   -16059.446   -16130.343   -16130.343    274.38087    274.38087    36397.611    36397.611   -344.24209   -344.24209 
Loop time of 9.87549 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.749 ns/day, 2.743 hours/ns, 101.261 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6802     | 9.6802     | 9.6802     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032822   | 0.032822   | 0.032822   |   0.0 |  0.33
Output  | 6.2498e-05 | 6.2498e-05 | 6.2498e-05 |   0.0 |  0.00
Modify  | 0.14329    | 0.14329    | 0.14329    |   0.0 |  1.45
Other   |            | 0.01911    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223290.0 ave      223290 max      223290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223290
Ave neighs/atom = 111.64500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.616045761314, Press = -1.88966016732768
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -16059.446   -16059.446   -16130.343   -16130.343    274.38087    274.38087    36397.611    36397.611   -344.24209   -344.24209 
   37000   -16056.808   -16056.808   -16128.634   -16128.634    277.97327    277.97327    36388.592    36388.592    652.94873    652.94873 
Loop time of 9.87558 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.749 ns/day, 2.743 hours/ns, 101.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    | 9.6803     | 9.6803     | 9.6803     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032711   | 0.032711   | 0.032711   |   0.0 |  0.33
Output  | 9.6077e-05 | 9.6077e-05 | 9.6077e-05 |   0.0 |  0.00
Modify  | 0.14334    | 0.14334    | 0.14334    |   0.0 |  1.45
Other   |            | 0.0191     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223412.0 ave      223412 max      223412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223412
Ave neighs/atom = 111.70600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.665892192709, Press = -0.921262587897508
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -16056.808   -16056.808   -16128.634   -16128.634    277.97327    277.97327    36388.592    36388.592    652.94873    652.94873 
   38000   -16059.282   -16059.282   -16128.321   -16128.321    267.18781    267.18781    36405.714    36405.714   -554.15518   -554.15518 
Loop time of 9.87009 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.754 ns/day, 2.742 hours/ns, 101.316 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6742     | 9.6742     | 9.6742     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032927   | 0.032927   | 0.032927   |   0.0 |  0.33
Output  | 6.2821e-05 | 6.2821e-05 | 6.2821e-05 |   0.0 |  0.00
Modify  | 0.1437     | 0.1437     | 0.1437     |   0.0 |  1.46
Other   |            | 0.0192     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223390.0 ave      223390 max      223390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223390
Ave neighs/atom = 111.69500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.693100526507, Press = -1.41683216353405
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -16059.282   -16059.282   -16128.321   -16128.321    267.18781    267.18781    36405.714    36405.714   -554.15518   -554.15518 
   39000   -16060.526   -16060.526   -16128.729   -16128.729    263.95237    263.95237    36406.643    36406.643   -568.69492   -568.69492 
Loop time of 9.87101 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.753 ns/day, 2.742 hours/ns, 101.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    | 9.6759     | 9.6759     | 9.6759     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032729   | 0.032729   | 0.032729   |   0.0 |  0.33
Output  | 6.3406e-05 | 6.3406e-05 | 6.3406e-05 |   0.0 |  0.00
Modify  | 0.14325    | 0.14325    | 0.14325    |   0.0 |  1.45
Other   |            | 0.01906    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223302.0 ave      223302 max      223302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223302
Ave neighs/atom = 111.65100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.602146169947, Press = -2.61652616422514
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -16060.526   -16060.526   -16128.729   -16128.729    263.95237    263.95237    36406.643    36406.643   -568.69492   -568.69492 
   40000   -16057.254   -16057.254    -16127.93    -16127.93    273.52562    273.52562    36390.345    36390.345    456.95678    456.95678 
Loop time of 9.86022 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.762 ns/day, 2.739 hours/ns, 101.418 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6643     | 9.6643     | 9.6643     |   0.0 | 98.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032753   | 0.032753   | 0.032753   |   0.0 |  0.33
Output  | 6.369e-05  | 6.369e-05  | 6.369e-05  |   0.0 |  0.00
Modify  | 0.14381    | 0.14381    | 0.14381    |   0.0 |  1.46
Other   |            | 0.01926    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223364.0 ave      223364 max      223364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223364
Ave neighs/atom = 111.68200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.598974648824, Press = -0.0958800012014774
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -16057.254   -16057.254    -16127.93    -16127.93    273.52562    273.52562    36390.345    36390.345    456.95678    456.95678 
   41000   -16060.592   -16060.592   -16131.001   -16131.001    272.48733    272.48733     36402.77     36402.77   -1069.4855   -1069.4855 
Loop time of 9.87873 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.746 ns/day, 2.744 hours/ns, 101.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    | 9.6831     | 9.6831     | 9.6831     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03274    | 0.03274    | 0.03274    |   0.0 |  0.33
Output  | 6.1626e-05 | 6.1626e-05 | 6.1626e-05 |   0.0 |  0.00
Modify  | 0.14369    | 0.14369    | 0.14369    |   0.0 |  1.45
Other   |            | 0.01918    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223300.0 ave      223300 max      223300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223300
Ave neighs/atom = 111.65000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.632182725344, Press = -1.79370522164327
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -16060.592   -16060.592   -16131.001   -16131.001    272.48733    272.48733     36402.77     36402.77   -1069.4855   -1069.4855 
   42000   -16058.017   -16058.017   -16127.794   -16127.794    270.04453    270.04453     36403.28     36403.28   -49.937976   -49.937976 
Loop time of 9.86996 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.754 ns/day, 2.742 hours/ns, 101.317 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6743     | 9.6743     | 9.6743     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032859   | 0.032859   | 0.032859   |   0.0 |  0.33
Output  | 6.2914e-05 | 6.2914e-05 | 6.2914e-05 |   0.0 |  0.00
Modify  | 0.14358    | 0.14358    | 0.14358    |   0.0 |  1.45
Other   |            | 0.0192     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223314.0 ave      223314 max      223314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223314
Ave neighs/atom = 111.65700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.646611281393, Press = -0.890118818120905
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -16058.017   -16058.017   -16127.794   -16127.794    270.04453    270.04453     36403.28     36403.28   -49.937976   -49.937976 
   43000   -16060.095   -16060.095   -16129.236   -16129.236    267.58041    267.58041    36372.937    36372.937    1111.6998    1111.6998 
Loop time of 9.88343 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.742 ns/day, 2.745 hours/ns, 101.179 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6872     | 9.6872     | 9.6872     |   0.0 | 98.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032899   | 0.032899   | 0.032899   |   0.0 |  0.33
Output  | 9.409e-05  | 9.409e-05  | 9.409e-05  |   0.0 |  0.00
Modify  | 0.14396    | 0.14396    | 0.14396    |   0.0 |  1.46
Other   |            | 0.01927    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223332.0 ave      223332 max      223332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223332
Ave neighs/atom = 111.66600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.56844647503, Press = -0.81413866559065
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -16060.095   -16060.095   -16129.236   -16129.236    267.58041    267.58041    36372.937    36372.937    1111.6998    1111.6998 
   44000   -16059.363   -16059.363   -16130.483   -16130.483    275.24391    275.24391    36385.181    36385.181    286.58156    286.58156 
Loop time of 9.8755 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.749 ns/day, 2.743 hours/ns, 101.261 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6799     | 9.6799     | 9.6799     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032691   | 0.032691   | 0.032691   |   0.0 |  0.33
Output  | 6.2116e-05 | 6.2116e-05 | 6.2116e-05 |   0.0 |  0.00
Modify  | 0.14366    | 0.14366    | 0.14366    |   0.0 |  1.45
Other   |            | 0.01922    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223408.0 ave      223408 max      223408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223408
Ave neighs/atom = 111.70400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.551678212407, Press = -0.921794916595371
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -16059.363   -16059.363   -16130.483   -16130.483    275.24391    275.24391    36385.181    36385.181    286.58156    286.58156 
   45000    -16059.09    -16059.09   -16129.081   -16129.081    270.87275    270.87275    36389.927    36389.927    359.89128    359.89128 
Loop time of 9.74433 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.867 ns/day, 2.707 hours/ns, 102.624 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5523     | 9.5523     | 9.5523     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032372   | 0.032372   | 0.032372   |   0.0 |  0.33
Output  | 6.1352e-05 | 6.1352e-05 | 6.1352e-05 |   0.0 |  0.00
Modify  | 0.14085    | 0.14085    | 0.14085    |   0.0 |  1.45
Other   |            | 0.01879    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223372.0 ave      223372 max      223372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223372
Ave neighs/atom = 111.68600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.472460907366, Press = -0.967475856811273
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000    -16059.09    -16059.09   -16129.081   -16129.081    270.87275    270.87275    36389.927    36389.927    359.89128    359.89128 
   46000   -16059.997   -16059.997    -16128.86    -16128.86    266.50542    266.50542    36391.963    36391.963     162.6819     162.6819 
Loop time of 9.72164 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.887 ns/day, 2.700 hours/ns, 102.863 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5304     | 9.5304     | 9.5304     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032213   | 0.032213   | 0.032213   |   0.0 |  0.33
Output  | 6.1909e-05 | 6.1909e-05 | 6.1909e-05 |   0.0 |  0.00
Modify  | 0.14027    | 0.14027    | 0.14027    |   0.0 |  1.44
Other   |            | 0.01871    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223404.0 ave      223404 max      223404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223404
Ave neighs/atom = 111.70200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.451079164212, Press = -1.73162218569576
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -16059.997   -16059.997    -16128.86    -16128.86    266.50542    266.50542    36391.963    36391.963     162.6819     162.6819 
   47000   -16056.906   -16056.906   -16128.972   -16128.972    278.90067    278.90067    36384.346    36384.346    879.86789    879.86789 
Loop time of 9.69823 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.909 ns/day, 2.694 hours/ns, 103.112 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5068     | 9.5068     | 9.5068     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032345   | 0.032345   | 0.032345   |   0.0 |  0.33
Output  | 6.0494e-05 | 6.0494e-05 | 6.0494e-05 |   0.0 |  0.00
Modify  | 0.1404     | 0.1404     | 0.1404     |   0.0 |  1.45
Other   |            | 0.01866    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223332.0 ave      223332 max      223332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223332
Ave neighs/atom = 111.66600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.415027291179, Press = -1.97937098609932
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -16056.906   -16056.906   -16128.972   -16128.972    278.90067    278.90067    36384.346    36384.346    879.86789    879.86789 
   48000   -16060.243   -16060.243   -16130.927   -16130.927    273.55319    273.55319    36408.087    36408.087   -1364.1169   -1364.1169 
Loop time of 9.70665 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.901 ns/day, 2.696 hours/ns, 103.022 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5154     | 9.5154     | 9.5154     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032298   | 0.032298   | 0.032298   |   0.0 |  0.33
Output  | 6.1557e-05 | 6.1557e-05 | 6.1557e-05 |   0.0 |  0.00
Modify  | 0.14024    | 0.14024    | 0.14024    |   0.0 |  1.44
Other   |            | 0.01867    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223404.0 ave      223404 max      223404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223404
Ave neighs/atom = 111.70200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.426182157241, Press = -0.664957726423119
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -16060.243   -16060.243   -16130.927   -16130.927    273.55319    273.55319    36408.087    36408.087   -1364.1169   -1364.1169 
   49000    -16057.35    -16057.35   -16128.851   -16128.851    276.71547    276.71547    36382.588    36382.588    771.80115    771.80115 
Loop time of 9.71168 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.897 ns/day, 2.698 hours/ns, 102.969 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5199     | 9.5199     | 9.5199     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032313   | 0.032313   | 0.032313   |   0.0 |  0.33
Output  | 9.6186e-05 | 9.6186e-05 | 9.6186e-05 |   0.0 |  0.00
Modify  | 0.14071    | 0.14071    | 0.14071    |   0.0 |  1.45
Other   |            | 0.0187     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223394.0 ave      223394 max      223394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223394
Ave neighs/atom = 111.69700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.461636920281, Press = 0.626210900982668
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000    -16057.35    -16057.35   -16128.851   -16128.851    276.71547    276.71547    36382.588    36382.588    771.80115    771.80115 
   50000   -16060.736   -16060.736   -16130.714   -16130.714    270.82569    270.82569    36376.579    36376.579    903.30356    903.30356 
Loop time of 9.6988 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.908 ns/day, 2.694 hours/ns, 103.106 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5072     | 9.5072     | 9.5072     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032457   | 0.032457   | 0.032457   |   0.0 |  0.33
Output  | 6.6824e-05 | 6.6824e-05 | 6.6824e-05 |   0.0 |  0.00
Modify  | 0.14044    | 0.14044    | 0.14044    |   0.0 |  1.45
Other   |            | 0.01863    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223306.0 ave      223306 max      223306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223306
Ave neighs/atom = 111.65300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.46839120778, Press = -1.94009696074299
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -16060.736   -16060.736   -16130.714   -16130.714    270.82569    270.82569    36376.579    36376.579    903.30356    903.30356 
   51000   -16058.094   -16058.094   -16128.915   -16128.915    274.08359    274.08359    36369.167    36369.167    1693.6428    1693.6428 
Loop time of 9.71033 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.898 ns/day, 2.697 hours/ns, 102.983 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5183     | 9.5183     | 9.5183     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032286   | 0.032286   | 0.032286   |   0.0 |  0.33
Output  | 6.7451e-05 | 6.7451e-05 | 6.7451e-05 |   0.0 |  0.00
Modify  | 0.14087    | 0.14087    | 0.14087    |   0.0 |  1.45
Other   |            | 0.01885    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223390.0 ave      223390 max      223390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223390
Ave neighs/atom = 111.69500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.430931149713, Press = -0.153185799732008
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -16058.094   -16058.094   -16128.915   -16128.915    274.08359    274.08359    36369.167    36369.167    1693.6428    1693.6428 
   52000   -16061.344   -16061.344   -16130.229   -16130.229     266.5922     266.5922    36383.635    36383.635    412.78995    412.78995 
Loop time of 9.72357 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.886 ns/day, 2.701 hours/ns, 102.843 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5312     | 9.5312     | 9.5312     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032514   | 0.032514   | 0.032514   |   0.0 |  0.33
Output  | 6.1886e-05 | 6.1886e-05 | 6.1886e-05 |   0.0 |  0.00
Modify  | 0.14095    | 0.14095    | 0.14095    |   0.0 |  1.45
Other   |            | 0.01882    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223380.0 ave      223380 max      223380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223380
Ave neighs/atom = 111.69000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.423713459126, Press = -1.82984043536501
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -16061.344   -16061.344   -16130.229   -16130.229     266.5922     266.5922    36383.635    36383.635    412.78995    412.78995 
   53000   -16060.506   -16060.506   -16130.654   -16130.654    271.48251    271.48251    36376.023    36376.023    794.77411    794.77411 
Loop time of 9.71633 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.892 ns/day, 2.699 hours/ns, 102.920 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5239     | 9.5239     | 9.5239     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032424   | 0.032424   | 0.032424   |   0.0 |  0.33
Output  | 6.8722e-05 | 6.8722e-05 | 6.8722e-05 |   0.0 |  0.00
Modify  | 0.14111    | 0.14111    | 0.14111    |   0.0 |  1.45
Other   |            | 0.01886    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223422.0 ave      223422 max      223422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223422
Ave neighs/atom = 111.71100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.428448622768, Press = -0.577595798175558
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -16060.506   -16060.506   -16130.654   -16130.654    271.48251    271.48251    36376.023    36376.023    794.77411    794.77411 
   54000   -16058.972   -16058.972   -16128.803   -16128.803    270.25676    270.25676    36391.923    36391.923     355.4599     355.4599 
Loop time of 9.71946 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.889 ns/day, 2.700 hours/ns, 102.886 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5271     | 9.5271     | 9.5271     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032355   | 0.032355   | 0.032355   |   0.0 |  0.33
Output  | 6.3338e-05 | 6.3338e-05 | 6.3338e-05 |   0.0 |  0.00
Modify  | 0.14104    | 0.14104    | 0.14104    |   0.0 |  1.45
Other   |            | 0.01889    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223400.0 ave      223400 max      223400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223400
Ave neighs/atom = 111.70000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.420882386066, Press = -0.99990931170486
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -16058.972   -16058.972   -16128.803   -16128.803    270.25676    270.25676    36391.923    36391.923     355.4599     355.4599 
   55000   -16057.871   -16057.871   -16129.625   -16129.625    277.69529    277.69529    36406.402    36406.402   -491.03172   -491.03172 
Loop time of 9.72158 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.887 ns/day, 2.700 hours/ns, 102.864 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5294     | 9.5294     | 9.5294     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032396   | 0.032396   | 0.032396   |   0.0 |  0.33
Output  | 9.3286e-05 | 9.3286e-05 | 9.3286e-05 |   0.0 |  0.00
Modify  | 0.14085    | 0.14085    | 0.14085    |   0.0 |  1.45
Other   |            | 0.01884    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223394.0 ave      223394 max      223394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223394
Ave neighs/atom = 111.69700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.404021583262, Press = -1.12625591097053
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -16057.871   -16057.871   -16129.625   -16129.625    277.69529    277.69529    36406.402    36406.402   -491.03172   -491.03172 
   56000   -16061.195   -16061.195   -16130.094   -16130.094    266.64651    266.64651    36353.029    36353.029    2058.3566    2058.3566 
Loop time of 9.72861 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.881 ns/day, 2.702 hours/ns, 102.790 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5362     | 9.5362     | 9.5362     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032294   | 0.032294   | 0.032294   |   0.0 |  0.33
Output  | 7.1582e-05 | 7.1582e-05 | 7.1582e-05 |   0.0 |  0.00
Modify  | 0.14117    | 0.14117    | 0.14117    |   0.0 |  1.45
Other   |            | 0.01888    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223402.0 ave      223402 max      223402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223402
Ave neighs/atom = 111.70100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.38261814356, Press = -0.397842729880164
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -16061.195   -16061.195   -16130.094   -16130.094    266.64651    266.64651    36353.029    36353.029    2058.3566    2058.3566 
   57000    -16056.45    -16056.45     -16129.3     -16129.3     281.9372     281.9372     36458.57     36458.57   -3260.6051   -3260.6051 
Loop time of 9.71256 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.896 ns/day, 2.698 hours/ns, 102.959 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5206     | 9.5206     | 9.5206     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032271   | 0.032271   | 0.032271   |   0.0 |  0.33
Output  | 6.2071e-05 | 6.2071e-05 | 6.2071e-05 |   0.0 |  0.00
Modify  | 0.14084    | 0.14084    | 0.14084    |   0.0 |  1.45
Other   |            | 0.01877    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223434.0 ave      223434 max      223434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223434
Ave neighs/atom = 111.71700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.380484348814, Press = -1.22176933161289
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000    -16056.45    -16056.45     -16129.3     -16129.3     281.9372     281.9372     36458.57     36458.57   -3260.6051   -3260.6051 
   58000   -16060.562   -16060.562    -16130.92    -16130.92    272.29175    272.29175    36410.893    36410.893   -1155.5224   -1155.5224 
Loop time of 9.82008 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.798 ns/day, 2.728 hours/ns, 101.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    | 9.623      | 9.623      | 9.623      |   0.0 | 97.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032784   | 0.032784   | 0.032784   |   0.0 |  0.33
Output  | 6.3452e-05 | 6.3452e-05 | 6.3452e-05 |   0.0 |  0.00
Modify  | 0.14446    | 0.14446    | 0.14446    |   0.0 |  1.47
Other   |            | 0.01974    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223258.0 ave      223258 max      223258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223258
Ave neighs/atom = 111.62900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.40654129279, Press = -1.37746033542607
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -16060.562   -16060.562    -16130.92    -16130.92    272.29175    272.29175    36410.893    36410.893   -1155.5224   -1155.5224 
   59000   -16057.878   -16057.878   -16127.707   -16127.707    270.24837    270.24837    36361.321    36361.321    2245.2142    2245.2142 
Loop time of 9.91104 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.718 ns/day, 2.753 hours/ns, 100.898 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.7105     | 9.7105     | 9.7105     |   0.0 | 97.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.033203   | 0.033203   | 0.033203   |   0.0 |  0.34
Output  | 6.2824e-05 | 6.2824e-05 | 6.2824e-05 |   0.0 |  0.00
Modify  | 0.14701    | 0.14701    | 0.14701    |   0.0 |  1.48
Other   |            | 0.02021    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223338.0 ave      223338 max      223338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223338
Ave neighs/atom = 111.66900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.45984018038, Press = -0.0147560792003876
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -16057.878   -16057.878   -16127.707   -16127.707    270.24837    270.24837    36361.321    36361.321    2245.2142    2245.2142 
   60000   -16061.881   -16061.881   -16133.102   -16133.102    275.63413    275.63413    36392.522    36392.522   -645.08192   -645.08192 
Loop time of 9.82703 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.792 ns/day, 2.730 hours/ns, 101.760 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6306     | 9.6306     | 9.6306     |   0.0 | 98.00
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032786   | 0.032786   | 0.032786   |   0.0 |  0.33
Output  | 6.6662e-05 | 6.6662e-05 | 6.6662e-05 |   0.0 |  0.00
Modify  | 0.14411    | 0.14411    | 0.14411    |   0.0 |  1.47
Other   |            | 0.0195     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223324.0 ave      223324 max      223324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223324
Ave neighs/atom = 111.66200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.427535293849, Press = -1.13848607589215
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -16061.881   -16061.881   -16133.102   -16133.102    275.63413    275.63413    36392.522    36392.522   -645.08192   -645.08192 
   61000   -16058.414   -16058.414   -16130.184   -16130.184    277.75433    277.75433    36392.417    36392.417   -46.593079   -46.593079 
Loop time of 9.82781 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.791 ns/day, 2.730 hours/ns, 101.752 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6311     | 9.6311     | 9.6311     |   0.0 | 98.00
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03295    | 0.03295    | 0.03295    |   0.0 |  0.34
Output  | 9.1249e-05 | 9.1249e-05 | 9.1249e-05 |   0.0 |  0.00
Modify  | 0.1442     | 0.1442     | 0.1442     |   0.0 |  1.47
Other   |            | 0.01945    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223428.0 ave      223428 max      223428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223428
Ave neighs/atom = 111.71400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.386486096733, Press = -1.09496112556004
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -16058.414   -16058.414   -16130.184   -16130.184    277.75433    277.75433    36392.417    36392.417   -46.593079   -46.593079 
   62000   -16060.703   -16060.703   -16130.032   -16130.032    268.31025    268.31025     36351.76     36351.76    2418.0497    2418.0497 
Loop time of 9.8671 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.756 ns/day, 2.741 hours/ns, 101.347 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6685     | 9.6685     | 9.6685     |   0.0 | 97.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032962   | 0.032962   | 0.032962   |   0.0 |  0.33
Output  | 6.1427e-05 | 6.1427e-05 | 6.1427e-05 |   0.0 |  0.00
Modify  | 0.14573    | 0.14573    | 0.14573    |   0.0 |  1.48
Other   |            | 0.01986    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223420.0 ave      223420 max      223420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223420
Ave neighs/atom = 111.71000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.359541410041, Press = -0.613955584775864
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -16060.703   -16060.703   -16130.032   -16130.032    268.31025    268.31025     36351.76     36351.76    2418.0497    2418.0497 
   63000   -16056.674   -16056.674   -16127.774   -16127.774    275.16566    275.16566    36403.579    36403.579   -71.850809   -71.850809 
Loop time of 9.83266 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.787 ns/day, 2.731 hours/ns, 101.702 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.633      | 9.633      | 9.633      |   0.0 | 97.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032907   | 0.032907   | 0.032907   |   0.0 |  0.33
Output  | 6.263e-05  | 6.263e-05  | 6.263e-05  |   0.0 |  0.00
Modify  | 0.14643    | 0.14643    | 0.14643    |   0.0 |  1.49
Other   |            | 0.02028    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223444.0 ave      223444 max      223444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223444
Ave neighs/atom = 111.72200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.376176714637, Press = -0.989237823660568
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -16056.674   -16056.674   -16127.774   -16127.774    275.16566    275.16566    36403.579    36403.579   -71.850809   -71.850809 
   64000   -16058.331   -16058.331   -16127.815   -16127.815    268.90991    268.90991    36415.537    36415.537    -618.8209    -618.8209 
Loop time of 9.78555 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.829 ns/day, 2.718 hours/ns, 102.192 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5887     | 9.5887     | 9.5887     |   0.0 | 97.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032705   | 0.032705   | 0.032705   |   0.0 |  0.33
Output  | 6.3025e-05 | 6.3025e-05 | 6.3025e-05 |   0.0 |  0.00
Modify  | 0.14439    | 0.14439    | 0.14439    |   0.0 |  1.48
Other   |            | 0.01969    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223334.0 ave      223334 max      223334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223334
Ave neighs/atom = 111.66700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.377942480685, Press = -0.657532370954629
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -16058.331   -16058.331   -16127.815   -16127.815    268.90991    268.90991    36415.537    36415.537    -618.8209    -618.8209 
   65000   -16059.304   -16059.304   -16130.671   -16130.671    276.19673    276.19673    36410.508    36410.508    -1340.961    -1340.961 
Loop time of 9.81894 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.799 ns/day, 2.727 hours/ns, 101.844 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6216     | 9.6216     | 9.6216     |   0.0 | 97.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032878   | 0.032878   | 0.032878   |   0.0 |  0.33
Output  | 6.2809e-05 | 6.2809e-05 | 6.2809e-05 |   0.0 |  0.00
Modify  | 0.14486    | 0.14486    | 0.14486    |   0.0 |  1.48
Other   |            | 0.01957    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223348.0 ave      223348 max      223348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223348
Ave neighs/atom = 111.67400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.386339824925, Press = -1.50858528818479
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -16059.304   -16059.304   -16130.671   -16130.671    276.19673    276.19673    36410.508    36410.508    -1340.961    -1340.961 
   66000   -16056.144   -16056.144   -16127.368   -16127.368    275.64426    275.64426     36408.83     36408.83   -145.25901   -145.25901 
Loop time of 9.78595 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.829 ns/day, 2.718 hours/ns, 102.187 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5923     | 9.5923     | 9.5923     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032768   | 0.032768   | 0.032768   |   0.0 |  0.33
Output  | 7.0602e-05 | 7.0602e-05 | 7.0602e-05 |   0.0 |  0.00
Modify  | 0.14185    | 0.14185    | 0.14185    |   0.0 |  1.45
Other   |            | 0.01895    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223306.0 ave      223306 max      223306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223306
Ave neighs/atom = 111.65300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.408183927606, Press = -0.407569084751746
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -16056.144   -16056.144   -16127.368   -16127.368    275.64426    275.64426     36408.83     36408.83   -145.25901   -145.25901 
   67000   -16060.437   -16060.437   -16131.104   -16131.104    273.48566    273.48566    36382.523    36382.523    230.01117    230.01117 
Loop time of 9.8183 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.800 ns/day, 2.727 hours/ns, 101.851 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6207     | 9.6207     | 9.6207     |   0.0 | 97.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032897   | 0.032897   | 0.032897   |   0.0 |  0.34
Output  | 9.2157e-05 | 9.2157e-05 | 9.2157e-05 |   0.0 |  0.00
Modify  | 0.1449     | 0.1449     | 0.1449     |   0.0 |  1.48
Other   |            | 0.01975    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223316.0 ave      223316 max      223316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223316
Ave neighs/atom = 111.65800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.425689952095, Press = -1.77090708958704
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -16060.437   -16060.437   -16131.104   -16131.104    273.48566    273.48566    36382.523    36382.523    230.01117    230.01117 
   68000   -16058.171   -16058.171   -16129.723   -16129.723    276.91519    276.91519    36416.295    36416.295   -1409.2145   -1409.2145 
Loop time of 9.75568 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.856 ns/day, 2.710 hours/ns, 102.504 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5608     | 9.5608     | 9.5608     |   0.0 | 98.00
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032451   | 0.032451   | 0.032451   |   0.0 |  0.33
Output  | 7.4159e-05 | 7.4159e-05 | 7.4159e-05 |   0.0 |  0.00
Modify  | 0.14303    | 0.14303    | 0.14303    |   0.0 |  1.47
Other   |            | 0.01936    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223346.0 ave      223346 max      223346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223346
Ave neighs/atom = 111.67300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.446205997728, Press = -0.288633169529596
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -16058.171   -16058.171   -16129.723   -16129.723    276.91519    276.91519    36416.295    36416.295   -1409.2145   -1409.2145 
   69000   -16060.648   -16060.648   -16130.239   -16130.239    269.32466    269.32466    36336.407    36336.407    3081.8626    3081.8626 
Loop time of 9.77411 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.840 ns/day, 2.715 hours/ns, 102.311 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.579      | 9.579      | 9.579      |   0.0 | 98.00
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032548   | 0.032548   | 0.032548   |   0.0 |  0.33
Output  | 6.3575e-05 | 6.3575e-05 | 6.3575e-05 |   0.0 |  0.00
Modify  | 0.14311    | 0.14311    | 0.14311    |   0.0 |  1.46
Other   |            | 0.01939    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223252.0 ave      223252 max      223252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223252
Ave neighs/atom = 111.62600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.413026019047, Press = -0.277805544169443
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -16060.648   -16060.648   -16130.239   -16130.239    269.32466    269.32466    36336.407    36336.407    3081.8626    3081.8626 
   70000   -16061.631   -16061.631    -16131.47    -16131.47    270.28432    270.28432    36381.402    36381.402    391.42661    391.42661 
Loop time of 9.75347 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.858 ns/day, 2.709 hours/ns, 102.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    | 9.5612     | 9.5612     | 9.5612     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032484   | 0.032484   | 0.032484   |   0.0 |  0.33
Output  | 6.6022e-05 | 6.6022e-05 | 6.6022e-05 |   0.0 |  0.00
Modify  | 0.14076    | 0.14076    | 0.14076    |   0.0 |  1.44
Other   |            | 0.01895    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223444.0 ave      223444 max      223444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223444
Ave neighs/atom = 111.72200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.404370401554, Press = -0.70417950407585
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -16061.631   -16061.631    -16131.47    -16131.47    270.28432    270.28432    36381.402    36381.402    391.42661    391.42661 
   71000   -16058.814   -16058.814   -16128.977   -16128.977    271.53653    271.53653    36368.744    36368.744    1626.7575    1626.7575 
Loop time of 9.75832 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.854 ns/day, 2.711 hours/ns, 102.477 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5656     | 9.5656     | 9.5656     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032609   | 0.032609   | 0.032609   |   0.0 |  0.33
Output  | 6.4658e-05 | 6.4658e-05 | 6.4658e-05 |   0.0 |  0.00
Modify  | 0.141      | 0.141      | 0.141      |   0.0 |  1.44
Other   |            | 0.01906    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223424.0 ave      223424 max      223424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223424
Ave neighs/atom = 111.71200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.380106115435, Press = -0.694209882827104
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -16058.814   -16058.814   -16128.977   -16128.977    271.53653    271.53653    36368.744    36368.744    1626.7575    1626.7575 
   72000   -16062.219   -16062.219   -16131.521   -16131.521    268.20944    268.20944    36386.106    36386.106   -167.51748   -167.51748 
Loop time of 9.77651 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.838 ns/day, 2.716 hours/ns, 102.286 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5818     | 9.5818     | 9.5818     |   0.0 | 98.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032737   | 0.032737   | 0.032737   |   0.0 |  0.33
Output  | 6.8038e-05 | 6.8038e-05 | 6.8038e-05 |   0.0 |  0.00
Modify  | 0.14275    | 0.14275    | 0.14275    |   0.0 |  1.46
Other   |            | 0.01917    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223392.0 ave      223392 max      223392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223392
Ave neighs/atom = 111.69600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.348853552811, Press = -0.706339876717285
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -16062.219   -16062.219   -16131.521   -16131.521    268.20944    268.20944    36386.106    36386.106   -167.51748   -167.51748 
   73000   -16059.193   -16059.193   -16128.658   -16128.658    268.83632    268.83632    36437.771    36437.771   -2089.1585   -2089.1585 
Loop time of 9.82388 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.795 ns/day, 2.729 hours/ns, 101.793 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6292     | 9.6292     | 9.6292     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032646   | 0.032646   | 0.032646   |   0.0 |  0.33
Output  | 9.494e-05  | 9.494e-05  | 9.494e-05  |   0.0 |  0.00
Modify  | 0.14293    | 0.14293    | 0.14293    |   0.0 |  1.45
Other   |            | 0.01903    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223436.0 ave      223436 max      223436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223436
Ave neighs/atom = 111.71800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.338194832536, Press = -1.49178472226168
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -16059.193   -16059.193   -16128.658   -16128.658    268.83632    268.83632    36437.771    36437.771   -2089.1585   -2089.1585 
   74000   -16058.038   -16058.038   -16128.648   -16128.648    273.26625    273.26625    36396.665    36396.665    334.83567    334.83567 
Loop time of 10.0574 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.591 ns/day, 2.794 hours/ns, 99.430 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.8531     | 9.8531     | 9.8531     |   0.0 | 97.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03391    | 0.03391    | 0.03391    |   0.0 |  0.34
Output  | 6.2339e-05 | 6.2339e-05 | 6.2339e-05 |   0.0 |  0.00
Modify  | 0.15012    | 0.15012    | 0.15012    |   0.0 |  1.49
Other   |            | 0.02014    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223370.0 ave      223370 max      223370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223370
Ave neighs/atom = 111.68500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.333895012145, Press = -0.789044981949743
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -16058.038   -16058.038   -16128.648   -16128.648    273.26625    273.26625    36396.665    36396.665    334.83567    334.83567 
   75000   -16059.961   -16059.961    -16130.43    -16130.43    272.72417    272.72417    36409.826    36409.826   -1009.3794   -1009.3794 
Loop time of 9.73259 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.877 ns/day, 2.703 hours/ns, 102.748 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5405     | 9.5405     | 9.5405     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032547   | 0.032547   | 0.032547   |   0.0 |  0.33
Output  | 6.5363e-05 | 6.5363e-05 | 6.5363e-05 |   0.0 |  0.00
Modify  | 0.14063    | 0.14063    | 0.14063    |   0.0 |  1.44
Other   |            | 0.01882    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      223356.0 ave      223356 max      223356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223356
Ave neighs/atom = 111.67800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
36394.9659695241

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0