# 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 293.15*${_u_temperature}
variable temp_converted equal 293.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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   -16124.125   -16124.125   -16199.872   -16199.872       293.15       293.15    36064.482    36064.482     2243.415     2243.415 
    1000   -16049.041   -16049.041   -16123.254   -16123.254    287.20929    287.20929    36412.686    36412.686    668.66087    668.66087 
Loop time of 10.7325 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.050 ns/day, 2.981 hours/ns, 93.175 timesteps/s
99.4% 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.503     | 10.503     | 10.503     |   0.0 | 97.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037781   | 0.037781   | 0.037781   |   0.0 |  0.35
Output  | 0.00023649 | 0.00023649 | 0.00023649 |   0.0 |  0.00
Modify  | 0.16568    | 0.16568    | 0.16568    |   0.0 |  1.54
Other   |            | 0.02562    |            |       |  0.24

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   -16049.041   -16049.041   -16123.254   -16123.254    287.20929    287.20929    36412.686    36412.686    668.66087    668.66087 
    2000   -16046.857   -16046.857   -16121.191   -16121.191    287.68236    287.68236    36482.634    36482.634   -2429.2131   -2429.2131 
Loop time of 10.1186 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.539 ns/day, 2.811 hours/ns, 98.828 timesteps/s
99.2% 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.9253     | 9.9253     | 9.9253     |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.033187   | 0.033187   | 0.033187   |   0.0 |  0.33
Output  | 0.00010453 | 0.00010453 | 0.00010453 |   0.0 |  0.00
Modify  | 0.14037    | 0.14037    | 0.14037    |   0.0 |  1.39
Other   |            | 0.01962    |            |       |  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:      223140.0 ave      223140 max      223140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223140
Ave neighs/atom = 111.57000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -16046.857   -16046.857   -16121.191   -16121.191    287.68236    287.68236    36482.634    36482.634   -2429.2131   -2429.2131 
    3000   -16051.789   -16051.789   -16128.034   -16128.034    295.07621    295.07621    36381.844    36381.844    1294.5316    1294.5316 
Loop time of 9.96198 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.673 ns/day, 2.767 hours/ns, 100.382 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.7718     | 9.7718     | 9.7718     |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032676   | 0.032676   | 0.032676   |   0.0 |  0.33
Output  | 0.00010378 | 0.00010378 | 0.00010378 |   0.0 |  0.00
Modify  | 0.13861    | 0.13861    | 0.13861    |   0.0 |  1.39
Other   |            | 0.01881    |            |       |  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:      222938.0 ave      222938 max      222938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222938
Ave neighs/atom = 111.46900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -16051.789   -16051.789   -16128.034   -16128.034    295.07621    295.07621    36381.844    36381.844    1294.5316    1294.5316 
    4000   -16044.616   -16044.616   -16124.511   -16124.511    309.19942    309.19942    36427.404    36427.404   -199.29479   -199.29479 
Loop time of 9.96473 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.671 ns/day, 2.768 hours/ns, 100.354 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.775      | 9.775      | 9.775      |   0.0 | 98.10
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032713   | 0.032713   | 0.032713   |   0.0 |  0.33
Output  | 0.00010729 | 0.00010729 | 0.00010729 |   0.0 |  0.00
Modify  | 0.13814    | 0.13814    | 0.13814    |   0.0 |  1.39
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:      223388.0 ave      223388 max      223388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223388
Ave neighs/atom = 111.69400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -16044.616   -16044.616   -16124.511   -16124.511    309.19942    309.19942    36427.404    36427.404   -199.29479   -199.29479 
    5000   -16051.633   -16051.633   -16124.602   -16124.602    282.39811    282.39811    36387.495    36387.495    1854.6682    1854.6682 
Loop time of 9.94736 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.686 ns/day, 2.763 hours/ns, 100.529 timesteps/s
100.0% 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.7572     | 9.7572     | 9.7572     |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032727   | 0.032727   | 0.032727   |   0.0 |  0.33
Output  | 8.2477e-05 | 8.2477e-05 | 8.2477e-05 |   0.0 |  0.00
Modify  | 0.13854    | 0.13854    | 0.13854    |   0.0 |  1.39
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:      223248.0 ave      223248 max      223248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223248
Ave neighs/atom = 111.62400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 283.907032305656, Press = -269.479000628618
next a
jump SELF top
variable a loop 2000
run 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   -16051.633   -16051.633   -16124.602   -16124.602    282.39811    282.39811    36387.495    36387.495    1854.6682    1854.6682 
    6000   -16047.964   -16047.964    -16124.63    -16124.63    296.70223    296.70223    36397.191    36397.191    1387.6814    1387.6814 
Loop time of 9.96769 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.668 ns/day, 2.769 hours/ns, 100.324 timesteps/s
100.0% 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.773      | 9.773      | 9.773      |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032523   | 0.032523   | 0.032523   |   0.0 |  0.33
Output  | 8.0423e-05 | 8.0423e-05 | 8.0423e-05 |   0.0 |  0.00
Modify  | 0.14316    | 0.14316    | 0.14316    |   0.0 |  1.44
Other   |            | 0.0189     |            |       |  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:      223198.0 ave      223198 max      223198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223198
Ave neighs/atom = 111.59900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.755267952334, Press = -41.6485372077902
next a
jump SELF top
variable a loop 2000
run 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   -16047.964   -16047.964    -16124.63    -16124.63    296.70223    296.70223    36397.191    36397.191    1387.6814    1387.6814 
    7000   -16051.803   -16051.803    -16126.83    -16126.83    290.36316    290.36316    36387.513    36387.513    1418.6578    1418.6578 
Loop time of 9.9742 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.662 ns/day, 2.771 hours/ns, 100.259 timesteps/s
100.0% 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.7801     | 9.7801     | 9.7801     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032453   | 0.032453   | 0.032453   |   0.0 |  0.33
Output  | 5.7516e-05 | 5.7516e-05 | 5.7516e-05 |   0.0 |  0.00
Modify  | 0.14269    | 0.14269    | 0.14269    |   0.0 |  1.43
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:      223210.0 ave      223210 max      223210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223210
Ave neighs/atom = 111.60500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.238307347679, Press = -11.9822003124034
next a
jump SELF top
variable a loop 2000
run 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   -16051.803   -16051.803    -16126.83    -16126.83    290.36316    290.36316    36387.513    36387.513    1418.6578    1418.6578 
    8000   -16050.105   -16050.105   -16126.301   -16126.301    294.88646    294.88646     36427.79     36427.79   -666.80108   -666.80108 
Loop time of 9.9734 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.663 ns/day, 2.770 hours/ns, 100.267 timesteps/s
100.0% 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.7791     | 9.7791     | 9.7791     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032722   | 0.032722   | 0.032722   |   0.0 |  0.33
Output  | 5.6315e-05 | 5.6315e-05 | 5.6315e-05 |   0.0 |  0.00
Modify  | 0.14268    | 0.14268    | 0.14268    |   0.0 |  1.43
Other   |            | 0.01887    |            |       |  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:      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 = 291.761220795726, Press = -11.4021020474944
next a
jump SELF top
variable a loop 2000
run 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   -16050.105   -16050.105   -16126.301   -16126.301    294.88646    294.88646     36427.79     36427.79   -666.80108   -666.80108 
    9000   -16046.164   -16046.164   -16122.959   -16122.959    297.20263    297.20263     36444.02     36444.02   -811.67716   -811.67716 
Loop time of 9.96651 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.669 ns/day, 2.768 hours/ns, 100.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.7722     | 9.7722     | 9.7722     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032766   | 0.032766   | 0.032766   |   0.0 |  0.33
Output  | 7.9754e-05 | 7.9754e-05 | 7.9754e-05 |   0.0 |  0.00
Modify  | 0.14262    | 0.14262    | 0.14262    |   0.0 |  1.43
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:      223330.0 ave      223330 max      223330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223330
Ave neighs/atom = 111.66500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.517707914149, Press = -2.94791147081475
next a
jump SELF top
variable a loop 2000
run 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   -16046.164   -16046.164   -16122.959   -16122.959    297.20263    297.20263     36444.02     36444.02   -811.67716   -811.67716 
   10000   -16045.915   -16045.915   -16122.131   -16122.131    294.96337    294.96337    36422.822    36422.822    431.65121    431.65121 
Loop time of 9.95682 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.677 ns/day, 2.766 hours/ns, 100.434 timesteps/s
100.0% 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.7626     | 9.7626     | 9.7626     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032703   | 0.032703   | 0.032703   |   0.0 |  0.33
Output  | 5.6323e-05 | 5.6323e-05 | 5.6323e-05 |   0.0 |  0.00
Modify  | 0.14272    | 0.14272    | 0.14272    |   0.0 |  1.43
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:      223076.0 ave      223076 max      223076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223076
Ave neighs/atom = 111.53800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.702575798926, Press = -8.28592088818977
next a
jump SELF top
variable a loop 2000
run 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   -16045.915   -16045.915   -16122.131   -16122.131    294.96337    294.96337    36422.822    36422.822    431.65121    431.65121 
   11000   -16049.392   -16049.392   -16126.306   -16126.306    297.66634    297.66634    36438.847    36438.847   -1498.5929   -1498.5929 
Loop time of 9.94755 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.686 ns/day, 2.763 hours/ns, 100.527 timesteps/s
100.0% 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.7535     | 9.7535     | 9.7535     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032697   | 0.032697   | 0.032697   |   0.0 |  0.33
Output  | 5.6853e-05 | 5.6853e-05 | 5.6853e-05 |   0.0 |  0.00
Modify  | 0.14258    | 0.14258    | 0.14258    |   0.0 |  1.43
Other   |            | 0.01872    |            |       |  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:      223110.0 ave      223110 max      223110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223110
Ave neighs/atom = 111.55500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.217394107075, Press = -11.015704678367
next a
jump SELF top
variable a loop 2000
run 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   -16049.392   -16049.392   -16126.306   -16126.306    297.66634    297.66634    36438.847    36438.847   -1498.5929   -1498.5929 
   12000   -16047.672   -16047.672   -16124.027   -16124.027    295.50066    295.50066    36406.084    36406.084    821.64319    821.64319 
Loop time of 9.94692 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.686 ns/day, 2.763 hours/ns, 100.534 timesteps/s
100.0% 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.7531     | 9.7531     | 9.7531     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032406   | 0.032406   | 0.032406   |   0.0 |  0.33
Output  | 5.6575e-05 | 5.6575e-05 | 5.6575e-05 |   0.0 |  0.00
Modify  | 0.14258    | 0.14258    | 0.14258    |   0.0 |  1.43
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:      223176.0 ave      223176 max      223176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223176
Ave neighs/atom = 111.58800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.200455642871, Press = -10.0982881892702
next a
jump SELF top
variable a loop 2000
run 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   -16047.672   -16047.672   -16124.027   -16124.027    295.50066    295.50066    36406.084    36406.084    821.64319    821.64319 
   13000   -16048.771   -16048.771   -16125.064   -16125.064    295.26488    295.26488    36402.463    36402.463    1080.2205    1080.2205 
Loop time of 9.96358 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.672 ns/day, 2.768 hours/ns, 100.366 timesteps/s
100.0% 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.7693     | 9.7693     | 9.7693     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032614   | 0.032614   | 0.032614   |   0.0 |  0.33
Output  | 8.3876e-05 | 8.3876e-05 | 8.3876e-05 |   0.0 |  0.00
Modify  | 0.14285    | 0.14285    | 0.14285    |   0.0 |  1.43
Other   |            | 0.01878    |            |       |  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:      223236.0 ave      223236 max      223236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223236
Ave neighs/atom = 111.61800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.584179149056, Press = -0.778433417404002
next a
jump SELF top
variable a loop 2000
run 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   -16048.771   -16048.771   -16125.064   -16125.064    295.26488    295.26488    36402.463    36402.463    1080.2205    1080.2205 
   14000   -16048.162   -16048.162   -16124.876   -16124.876    296.89171    296.89171    36407.128    36407.128    883.69672    883.69672 
Loop time of 9.97488 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.662 ns/day, 2.771 hours/ns, 100.252 timesteps/s
100.0% 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.7802     | 9.7802     | 9.7802     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032822   | 0.032822   | 0.032822   |   0.0 |  0.33
Output  | 5.8197e-05 | 5.8197e-05 | 5.8197e-05 |   0.0 |  0.00
Modify  | 0.14298    | 0.14298    | 0.14298    |   0.0 |  1.43
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:      223222.0 ave      223222 max      223222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223222
Ave neighs/atom = 111.61100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.494551800047, Press = 0.551730563689743
next a
jump SELF top
variable a loop 2000
run 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   -16048.162   -16048.162   -16124.876   -16124.876    296.89171    296.89171    36407.128    36407.128    883.69672    883.69672 
   15000   -16046.094   -16046.094   -16123.236   -16123.236    298.54934    298.54934    36450.293    36450.293   -1075.4717   -1075.4717 
Loop time of 9.95349 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.680 ns/day, 2.765 hours/ns, 100.467 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.7598     | 9.7598     | 9.7598     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032332   | 0.032332   | 0.032332   |   0.0 |  0.32
Output  | 7.3325e-05 | 7.3325e-05 | 7.3325e-05 |   0.0 |  0.00
Modify  | 0.14245    | 0.14245    | 0.14245    |   0.0 |  1.43
Other   |            | 0.01878    |            |       |  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:      223236.0 ave      223236 max      223236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223236
Ave neighs/atom = 111.61800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.451657716, Press = -1.69604907988011
next a
jump SELF top
variable a loop 2000
run 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   -16046.094   -16046.094   -16123.236   -16123.236    298.54934    298.54934    36450.293    36450.293   -1075.4717   -1075.4717 
   16000   -16051.206   -16051.206   -16125.317   -16125.317    286.81831    286.81831    36476.778    36476.778   -2810.6132   -2810.6132 
Loop time of 9.97477 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.662 ns/day, 2.771 hours/ns, 100.253 timesteps/s
100.0% 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.7805     | 9.7805     | 9.7805     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032776   | 0.032776   | 0.032776   |   0.0 |  0.33
Output  | 5.7184e-05 | 5.7184e-05 | 5.7184e-05 |   0.0 |  0.00
Modify  | 0.14263    | 0.14263    | 0.14263    |   0.0 |  1.43
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:      223040.0 ave      223040 max      223040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223040
Ave neighs/atom = 111.52000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.490701611904, Press = -4.32759582911013
next a
jump SELF top
variable a loop 2000
run 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   -16051.206   -16051.206   -16125.317   -16125.317    286.81831    286.81831    36476.778    36476.778   -2810.6132   -2810.6132 
   17000   -16048.356   -16048.356   -16125.136   -16125.136    297.14626    297.14626    36452.838    36452.838   -1746.5513   -1746.5513 
Loop time of 9.97675 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.660 ns/day, 2.771 hours/ns, 100.233 timesteps/s
100.0% 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.7825     | 9.7825     | 9.7825     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032614   | 0.032614   | 0.032614   |   0.0 |  0.33
Output  | 5.7717e-05 | 5.7717e-05 | 5.7717e-05 |   0.0 |  0.00
Modify  | 0.14268    | 0.14268    | 0.14268    |   0.0 |  1.43
Other   |            | 0.01893    |            |       |  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:      223286.0 ave      223286 max      223286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223286
Ave neighs/atom = 111.64300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.592763523708, Press = -4.57924265407018
next a
jump SELF top
variable a loop 2000
run 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   -16048.356   -16048.356   -16125.136   -16125.136    297.14626    297.14626    36452.838    36452.838   -1746.5513   -1746.5513 
   18000   -16048.814   -16048.814   -16126.219   -16126.219    299.56635    299.56635    36386.491    36386.491    1610.0511    1610.0511 
Loop time of 9.98268 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.655 ns/day, 2.773 hours/ns, 100.173 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.7883     | 9.7883     | 9.7883     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032462   | 0.032462   | 0.032462   |   0.0 |  0.33
Output  | 5.5768e-05 | 5.5768e-05 | 5.5768e-05 |   0.0 |  0.00
Modify  | 0.14282    | 0.14282    | 0.14282    |   0.0 |  1.43
Other   |            | 0.01904    |            |       |  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:      223184.0 ave      223184 max      223184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223184
Ave neighs/atom = 111.59200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.617860682213, Press = -2.95799418978863
next a
jump SELF top
variable a loop 2000
run 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   -16048.814   -16048.814   -16126.219   -16126.219    299.56635    299.56635    36386.491    36386.491    1610.0511    1610.0511 
   19000   -16047.449   -16047.449   -16123.091   -16123.091    292.74297    292.74297    36423.424    36423.424    339.54311    339.54311 
Loop time of 9.96481 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.671 ns/day, 2.768 hours/ns, 100.353 timesteps/s
100.0% 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.7706     | 9.7706     | 9.7706     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03239    | 0.03239    | 0.03239    |   0.0 |  0.33
Output  | 8.0607e-05 | 8.0607e-05 | 8.0607e-05 |   0.0 |  0.00
Modify  | 0.14285    | 0.14285    | 0.14285    |   0.0 |  1.43
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:      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 = 293.793826012616, Press = -1.62163034756163
next a
jump SELF top
variable a loop 2000
run 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   -16047.449   -16047.449   -16123.091   -16123.091    292.74297    292.74297    36423.424    36423.424    339.54311    339.54311 
   20000   -16051.585   -16051.585   -16123.479   -16123.479    278.23519    278.23519    36464.915    36464.915   -2110.1204   -2110.1204 
Loop time of 9.97815 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.659 ns/day, 2.772 hours/ns, 100.219 timesteps/s
100.0% 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.7834     | 9.7834     | 9.7834     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032729   | 0.032729   | 0.032729   |   0.0 |  0.33
Output  | 5.5574e-05 | 5.5574e-05 | 5.5574e-05 |   0.0 |  0.00
Modify  | 0.14308    | 0.14308    | 0.14308    |   0.0 |  1.43
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:      223198.0 ave      223198 max      223198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223198
Ave neighs/atom = 111.59900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.72765640689, Press = -6.38448574301448
next a
jump SELF top
variable a loop 2000
run 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   -16051.585   -16051.585   -16123.479   -16123.479    278.23519    278.23519    36464.915    36464.915   -2110.1204   -2110.1204 
   21000   -16048.258   -16048.258    -16124.47    -16124.47    294.94708    294.94708    36466.167    36466.167   -2458.5652   -2458.5652 
Loop time of 9.96893 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.667 ns/day, 2.769 hours/ns, 100.312 timesteps/s
100.0% 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.7744     | 9.7744     | 9.7744     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032668   | 0.032668   | 0.032668   |   0.0 |  0.33
Output  | 5.7138e-05 | 5.7138e-05 | 5.7138e-05 |   0.0 |  0.00
Modify  | 0.14304    | 0.14304    | 0.14304    |   0.0 |  1.43
Other   |            | 0.01881    |            |       |  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:      223118.0 ave      223118 max      223118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223118
Ave neighs/atom = 111.55900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.690535764561, Press = -5.24917280098758
next a
jump SELF top
variable a loop 2000
run 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   -16048.258   -16048.258    -16124.47    -16124.47    294.94708    294.94708    36466.167    36466.167   -2458.5652   -2458.5652 
   22000   -16050.918   -16050.918   -16124.593   -16124.593    285.12961    285.12961    36358.839    36358.839    3187.2876    3187.2876 
Loop time of 9.95903 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.676 ns/day, 2.766 hours/ns, 100.411 timesteps/s
100.0% 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.765      | 9.765      | 9.765      |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032551   | 0.032551   | 0.032551   |   0.0 |  0.33
Output  | 5.4319e-05 | 5.4319e-05 | 5.4319e-05 |   0.0 |  0.00
Modify  | 0.14254    | 0.14254    | 0.14254    |   0.0 |  1.43
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:      223072.0 ave      223072 max      223072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223072
Ave neighs/atom = 111.53600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.475318362572, Press = -0.527616733287072
next a
jump SELF top
variable a loop 2000
run 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   -16050.918   -16050.918   -16124.593   -16124.593    285.12961    285.12961    36358.839    36358.839    3187.2876    3187.2876 
   23000   -16049.277   -16049.277   -16124.411   -16124.411    290.77666    290.77666     36394.68     36394.68    1634.4324    1634.4324 
Loop time of 9.96822 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.668 ns/day, 2.769 hours/ns, 100.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.7742     | 9.7742     | 9.7742     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032705   | 0.032705   | 0.032705   |   0.0 |  0.33
Output  | 5.6461e-05 | 5.6461e-05 | 5.6461e-05 |   0.0 |  0.00
Modify  | 0.14246    | 0.14246    | 0.14246    |   0.0 |  1.43
Other   |            | 0.01875    |            |       |  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 = 293.478385925949, Press = -1.91801783009659
next a
jump SELF top
variable a loop 2000
run 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   -16049.277   -16049.277   -16124.411   -16124.411    290.77666    290.77666     36394.68     36394.68    1634.4324    1634.4324 
   24000   -16046.494   -16046.494   -16123.408   -16123.408    297.66432    297.66432    36432.912    36432.912   -297.38071   -297.38071 
Loop time of 9.97281 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.664 ns/day, 2.770 hours/ns, 100.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.7788     | 9.7788     | 9.7788     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032398   | 0.032398   | 0.032398   |   0.0 |  0.32
Output  | 5.7097e-05 | 5.7097e-05 | 5.7097e-05 |   0.0 |  0.00
Modify  | 0.14267    | 0.14267    | 0.14267    |   0.0 |  1.43
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:      223206.0 ave      223206 max      223206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223206
Ave neighs/atom = 111.60300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.571261473157, Press = 0.369011873905098
next a
jump SELF top
variable a loop 2000
run 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   -16046.494   -16046.494   -16123.408   -16123.408    297.66432    297.66432    36432.912    36432.912   -297.38071   -297.38071 
   25000   -16049.838   -16049.838   -16124.902   -16124.902    290.50539    290.50539    36411.998    36411.998    350.70432    350.70432 
Loop time of 9.95841 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.676 ns/day, 2.766 hours/ns, 100.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.7642     | 9.7642     | 9.7642     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032627   | 0.032627   | 0.032627   |   0.0 |  0.33
Output  | 8.3956e-05 | 8.3956e-05 | 8.3956e-05 |   0.0 |  0.00
Modify  | 0.14266    | 0.14266    | 0.14266    |   0.0 |  1.43
Other   |            | 0.01881    |            |       |  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:      223210.0 ave      223210 max      223210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223210
Ave neighs/atom = 111.60500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.585134199604, Press = -2.58712292710282
next a
jump SELF top
variable a loop 2000
run 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   -16049.838   -16049.838   -16124.902   -16124.902    290.50539    290.50539    36411.998    36411.998    350.70432    350.70432 
   26000   -16046.421   -16046.421   -16123.445   -16123.445    298.08868    298.08868    36421.831    36421.831     384.0107     384.0107 
Loop time of 9.96003 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.675 ns/day, 2.767 hours/ns, 100.401 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.7658     | 9.7658     | 9.7658     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032596   | 0.032596   | 0.032596   |   0.0 |  0.33
Output  | 5.5059e-05 | 5.5059e-05 | 5.5059e-05 |   0.0 |  0.00
Modify  | 0.14277    | 0.14277    | 0.14277    |   0.0 |  1.43
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:      223182.0 ave      223182 max      223182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223182
Ave neighs/atom = 111.59100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.63716828722, Press = -1.17734482103442
next a
jump SELF top
variable a loop 2000
run 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   -16046.421   -16046.421   -16123.445   -16123.445    298.08868    298.08868    36421.831    36421.831     384.0107     384.0107 
   27000    -16053.41    -16053.41   -16128.543   -16128.543    290.77151    290.77151    36359.934    36359.934    2448.6393    2448.6393 
Loop time of 9.95757 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.677 ns/day, 2.766 hours/ns, 100.426 timesteps/s
100.0% 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.7635     | 9.7635     | 9.7635     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032658   | 0.032658   | 0.032658   |   0.0 |  0.33
Output  | 5.6758e-05 | 5.6758e-05 | 5.6758e-05 |   0.0 |  0.00
Modify  | 0.14249    | 0.14249    | 0.14249    |   0.0 |  1.43
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:      223148.0 ave      223148 max      223148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223148
Ave neighs/atom = 111.57400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.599247041829, Press = -2.21712377735754
next a
jump SELF top
variable a loop 2000
run 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    -16053.41    -16053.41   -16128.543   -16128.543    290.77151    290.77151    36359.934    36359.934    2448.6393    2448.6393 
   28000   -16047.813   -16047.813   -16123.357   -16123.357    292.36263    292.36263    36390.505    36390.505     2079.489     2079.489 
Loop time of 9.9593 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.675 ns/day, 2.766 hours/ns, 100.409 timesteps/s
100.0% 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.7649     | 9.7649     | 9.7649     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032928   | 0.032928   | 0.032928   |   0.0 |  0.33
Output  | 5.6254e-05 | 5.6254e-05 | 5.6254e-05 |   0.0 |  0.00
Modify  | 0.14267    | 0.14267    | 0.14267    |   0.0 |  1.43
Other   |            | 0.01873    |            |       |  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 = 293.466537096486, Press = -0.859311258990099
next a
jump SELF top
variable a loop 2000
run 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   -16047.813   -16047.813   -16123.357   -16123.357    292.36263    292.36263    36390.505    36390.505     2079.489     2079.489 
   29000   -16047.707   -16047.707   -16125.055   -16125.055    299.34623    299.34623    36455.288    36455.288   -1672.5105   -1672.5105 
Loop time of 9.97295 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.663 ns/day, 2.770 hours/ns, 100.271 timesteps/s
100.0% 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.7787     | 9.7787     | 9.7787     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032774   | 0.032774   | 0.032774   |   0.0 |  0.33
Output  | 5.4793e-05 | 5.4793e-05 | 5.4793e-05 |   0.0 |  0.00
Modify  | 0.14271    | 0.14271    | 0.14271    |   0.0 |  1.43
Other   |            | 0.01874    |            |       |  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:      223188.0 ave      223188 max      223188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223188
Ave neighs/atom = 111.59400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.481716350106, Press = -1.31899224398891
next a
jump SELF top
variable a loop 2000
run 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   -16047.707   -16047.707   -16125.055   -16125.055    299.34623    299.34623    36455.288    36455.288   -1672.5105   -1672.5105 
   30000   -16047.583   -16047.583   -16124.392   -16124.392    297.25844    297.25844    36401.879    36401.879    1061.8982    1061.8982 
Loop time of 9.96464 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.671 ns/day, 2.768 hours/ns, 100.355 timesteps/s
100.0% 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.7705     | 9.7705     | 9.7705     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032482   | 0.032482   | 0.032482   |   0.0 |  0.33
Output  | 5.3796e-05 | 5.3796e-05 | 5.3796e-05 |   0.0 |  0.00
Modify  | 0.14284    | 0.14284    | 0.14284    |   0.0 |  1.43
Other   |            | 0.01874    |            |       |  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:      223102.0 ave      223102 max      223102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223102
Ave neighs/atom = 111.55100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.606023876924, Press = -2.11218865453731
next a
jump SELF top
variable a loop 2000
run 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   -16047.583   -16047.583   -16124.392   -16124.392    297.25844    297.25844    36401.879    36401.879    1061.8982    1061.8982 
   31000   -16051.713   -16051.713   -16126.715   -16126.715    290.26711    290.26711    36397.234    36397.234    626.00794    626.00794 
Loop time of 9.97788 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.659 ns/day, 2.772 hours/ns, 100.222 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.7836     | 9.7836     | 9.7836     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032729   | 0.032729   | 0.032729   |   0.0 |  0.33
Output  | 7.9145e-05 | 7.9145e-05 | 7.9145e-05 |   0.0 |  0.00
Modify  | 0.14266    | 0.14266    | 0.14266    |   0.0 |  1.43
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:      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 = 293.544625243185, Press = -1.7778495712288
next a
jump SELF top
variable a loop 2000
run 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   -16051.713   -16051.713   -16126.715   -16126.715    290.26711    290.26711    36397.234    36397.234    626.00794    626.00794 
   32000   -16050.126   -16050.126   -16125.336   -16125.336    291.06866    291.06866    36417.086    36417.086   -89.520342   -89.520342 
Loop time of 9.95152 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.682 ns/day, 2.764 hours/ns, 100.487 timesteps/s
100.0% 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.7576     | 9.7576     | 9.7576     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03253    | 0.03253    | 0.03253    |   0.0 |  0.33
Output  | 5.548e-05  | 5.548e-05  | 5.548e-05  |   0.0 |  0.00
Modify  | 0.14263    | 0.14263    | 0.14263    |   0.0 |  1.43
Other   |            | 0.01874    |            |       |  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:      223288.0 ave      223288 max      223288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223288
Ave neighs/atom = 111.64400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.549922149035, Press = -0.333313167895102
next a
jump SELF top
variable a loop 2000
run 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   -16050.126   -16050.126   -16125.336   -16125.336    291.06866    291.06866    36417.086    36417.086   -89.520342   -89.520342 
   33000   -16045.444   -16045.444   -16123.571   -16123.571    302.36291    302.36291    36389.119    36389.119    2212.6679    2212.6679 
Loop time of 9.96005 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.675 ns/day, 2.767 hours/ns, 100.401 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.7663     | 9.7663     | 9.7663     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03247    | 0.03247    | 0.03247    |   0.0 |  0.33
Output  | 5.4312e-05 | 5.4312e-05 | 5.4312e-05 |   0.0 |  0.00
Modify  | 0.14254    | 0.14254    | 0.14254    |   0.0 |  1.43
Other   |            | 0.01874    |            |       |  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:      223202.0 ave      223202 max      223202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223202
Ave neighs/atom = 111.60100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.602749959238, Press = -0.762989917615215
next a
jump SELF top
variable a loop 2000
run 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   -16045.444   -16045.444   -16123.571   -16123.571    302.36291    302.36291    36389.119    36389.119    2212.6679    2212.6679 
   34000   -16050.017   -16050.017    -16125.55    -16125.55     292.3209     292.3209    36421.604    36421.604   -337.87576   -337.87576 
Loop time of 9.95818 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.676 ns/day, 2.766 hours/ns, 100.420 timesteps/s
100.0% 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.7643     | 9.7643     | 9.7643     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032459   | 0.032459   | 0.032459   |   0.0 |  0.33
Output  | 5.6379e-05 | 5.6379e-05 | 5.6379e-05 |   0.0 |  0.00
Modify  | 0.14261    | 0.14261    | 0.14261    |   0.0 |  1.43
Other   |            | 0.01878    |            |       |  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 = 293.646739570884, Press = -0.453215658814942
next a
jump SELF top
variable a loop 2000
run 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   -16050.017   -16050.017    -16125.55    -16125.55     292.3209     292.3209    36421.604    36421.604   -337.87576   -337.87576 
   35000   -16047.654   -16047.654   -16123.492   -16123.492    293.50179    293.50179    36466.662    36466.662   -2047.8213   -2047.8213 
Loop time of 9.9575 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.677 ns/day, 2.766 hours/ns, 100.427 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.7638     | 9.7638     | 9.7638     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032348   | 0.032348   | 0.032348   |   0.0 |  0.32
Output  | 5.4277e-05 | 5.4277e-05 | 5.4277e-05 |   0.0 |  0.00
Modify  | 0.14251    | 0.14251    | 0.14251    |   0.0 |  1.43
Other   |            | 0.01874    |            |       |  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:      223192.0 ave      223192 max      223192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223192
Ave neighs/atom = 111.59600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.693958914611, Press = -0.403736194737562
next a
jump SELF top
variable a loop 2000
run 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   -16047.654   -16047.654   -16123.492   -16123.492    293.50179    293.50179    36466.662    36466.662   -2047.8213   -2047.8213 
   36000   -16048.998   -16048.998    -16124.52    -16124.52    292.27986    292.27986    36456.789    36456.789   -2069.1735   -2069.1735 
Loop time of 9.935 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.697 ns/day, 2.760 hours/ns, 100.654 timesteps/s
100.0% 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.7414     | 9.7414     | 9.7414     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032425   | 0.032425   | 0.032425   |   0.0 |  0.33
Output  | 6.7587e-05 | 6.7587e-05 | 6.7587e-05 |   0.0 |  0.00
Modify  | 0.14236    | 0.14236    | 0.14236    |   0.0 |  1.43
Other   |            | 0.01875    |            |       |  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:      223110.0 ave      223110 max      223110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223110
Ave neighs/atom = 111.55500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.67765092113, Press = -0.749879556069539
next a
jump SELF top
variable a loop 2000
run 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   -16048.998   -16048.998    -16124.52    -16124.52    292.27986    292.27986    36456.789    36456.789   -2069.1735   -2069.1735 
   37000   -16050.786   -16050.786   -16125.074   -16125.074    287.50131    287.50131      36459.4      36459.4   -2272.4821   -2272.4821 
Loop time of 9.9523 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.681 ns/day, 2.765 hours/ns, 100.479 timesteps/s
100.0% 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.7583     | 9.7583     | 9.7583     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032438   | 0.032438   | 0.032438   |   0.0 |  0.33
Output  | 8.1435e-05 | 8.1435e-05 | 8.1435e-05 |   0.0 |  0.00
Modify  | 0.14265    | 0.14265    | 0.14265    |   0.0 |  1.43
Other   |            | 0.01883    |            |       |  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:      223006.0 ave      223006 max      223006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223006
Ave neighs/atom = 111.50300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.700646352326, Press = -1.28986770809619
next a
jump SELF top
variable a loop 2000
run 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   -16050.786   -16050.786   -16125.074   -16125.074    287.50131    287.50131      36459.4      36459.4   -2272.4821   -2272.4821 
   38000   -16047.082   -16047.082   -16122.685   -16122.685    292.58938    292.58938    36443.661    36443.661   -778.57869   -778.57869 
Loop time of 9.96556 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.670 ns/day, 2.768 hours/ns, 100.346 timesteps/s
100.0% 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.7712     | 9.7712     | 9.7712     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032832   | 0.032832   | 0.032832   |   0.0 |  0.33
Output  | 5.6755e-05 | 5.6755e-05 | 5.6755e-05 |   0.0 |  0.00
Modify  | 0.14273    | 0.14273    | 0.14273    |   0.0 |  1.43
Other   |            | 0.01873    |            |       |  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:      223098.0 ave      223098 max      223098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223098
Ave neighs/atom = 111.54900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.615023362083, Press = -1.42865867281992
next a
jump SELF top
variable a loop 2000
run 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   -16047.082   -16047.082   -16122.685   -16122.685    292.58938    292.58938    36443.661    36443.661   -778.57869   -778.57869 
   39000   -16050.085   -16050.085   -16125.982   -16125.982     293.7275     293.7275    36384.277    36384.277    1828.6498    1828.6498 
Loop time of 9.95216 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.682 ns/day, 2.764 hours/ns, 100.481 timesteps/s
100.0% 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.7578     | 9.7578     | 9.7578     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032791   | 0.032791   | 0.032791   |   0.0 |  0.33
Output  | 5.6657e-05 | 5.6657e-05 | 5.6657e-05 |   0.0 |  0.00
Modify  | 0.14267    | 0.14267    | 0.14267    |   0.0 |  1.43
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:      223002.0 ave      223002 max      223002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223002
Ave neighs/atom = 111.50100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.63395936096, Press = 0.155357857903606
next a
jump SELF top
variable a loop 2000
run 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   -16050.085   -16050.085   -16125.982   -16125.982     293.7275     293.7275    36384.277    36384.277    1828.6498    1828.6498 
   40000    -16047.44    -16047.44   -16125.037   -16125.037    300.31014    300.31014    36380.207    36380.207    2343.6255    2343.6255 
Loop time of 9.96497 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.670 ns/day, 2.768 hours/ns, 100.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.7704     | 9.7704     | 9.7704     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032482   | 0.032482   | 0.032482   |   0.0 |  0.33
Output  | 5.5019e-05 | 5.5019e-05 | 5.5019e-05 |   0.0 |  0.00
Modify  | 0.14312    | 0.14312    | 0.14312    |   0.0 |  1.44
Other   |            | 0.01893    |            |       |  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:      223284.0 ave      223284 max      223284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223284
Ave neighs/atom = 111.64200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.682141753637, Press = 0.158445341865547
next a
jump SELF top
variable a loop 2000
run 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    -16047.44    -16047.44   -16125.037   -16125.037    300.31014    300.31014    36380.207    36380.207    2343.6255    2343.6255 
   41000   -16049.575   -16049.575   -16125.132   -16125.132    292.41431    292.41431    36371.046    36371.046    2722.4413    2722.4413 
Loop time of 9.96595 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.670 ns/day, 2.768 hours/ns, 100.342 timesteps/s
100.0% 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.7717     | 9.7717     | 9.7717     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032457   | 0.032457   | 0.032457   |   0.0 |  0.33
Output  | 5.6296e-05 | 5.6296e-05 | 5.6296e-05 |   0.0 |  0.00
Modify  | 0.14288    | 0.14288    | 0.14288    |   0.0 |  1.43
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:      223202.0 ave      223202 max      223202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223202
Ave neighs/atom = 111.60100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.688609169309, Press = -0.904323838593372
next a
jump SELF top
variable a loop 2000
run 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   -16049.575   -16049.575   -16125.132   -16125.132    292.41431    292.41431    36371.046    36371.046    2722.4413    2722.4413 
   42000   -16044.662   -16044.662   -16121.516   -16121.516    297.43033    297.43033    36409.519    36409.519    1411.1761    1411.1761 
Loop time of 9.90117 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.726 ns/day, 2.750 hours/ns, 100.998 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.708      | 9.708      | 9.708      |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032511   | 0.032511   | 0.032511   |   0.0 |  0.33
Output  | 5.645e-05  | 5.645e-05  | 5.645e-05  |   0.0 |  0.00
Modify  | 0.14171    | 0.14171    | 0.14171    |   0.0 |  1.43
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:      223286.0 ave      223286 max      223286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223286
Ave neighs/atom = 111.64300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.704467817894, Press = -0.137907015933879
next a
jump SELF top
variable a loop 2000
run 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   -16044.662   -16044.662   -16121.516   -16121.516    297.43033    297.43033    36409.519    36409.519    1411.1761    1411.1761 
   43000   -16047.425   -16047.425   -16126.428   -16126.428    305.75001    305.75001    36400.964    36400.964    419.69542    419.69542 
Loop time of 9.66825 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.936 ns/day, 2.686 hours/ns, 103.431 timesteps/s
100.0% 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.4781     | 9.4781     | 9.4781     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032307   | 0.032307   | 0.032307   |   0.0 |  0.33
Output  | 7.5932e-05 | 7.5932e-05 | 7.5932e-05 |   0.0 |  0.00
Modify  | 0.13912    | 0.13912    | 0.13912    |   0.0 |  1.44
Other   |            | 0.0186     |            |       |  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:      223086.0 ave      223086 max      223086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223086
Ave neighs/atom = 111.54300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.675260336426, Press = -0.568182701883559
next a
jump SELF top
variable a loop 2000
run 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   -16047.425   -16047.425   -16126.428   -16126.428    305.75001    305.75001    36400.964    36400.964    419.69542    419.69542 
   44000   -16051.246   -16051.246    -16125.91    -16125.91    288.95471    288.95471    36389.853    36389.853    1226.3853    1226.3853 
Loop time of 9.66956 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.935 ns/day, 2.686 hours/ns, 103.417 timesteps/s
100.0% 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.479      | 9.479      | 9.479      |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032388   | 0.032388   | 0.032388   |   0.0 |  0.33
Output  | 5.5247e-05 | 5.5247e-05 | 5.5247e-05 |   0.0 |  0.00
Modify  | 0.13945    | 0.13945    | 0.13945    |   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:      223280.0 ave      223280 max      223280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223280
Ave neighs/atom = 111.64000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.711772608942, Press = -1.26091381529886
next a
jump SELF top
variable a loop 2000
run 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   -16051.246   -16051.246    -16125.91    -16125.91    288.95471    288.95471    36389.853    36389.853    1226.3853    1226.3853 
   45000   -16048.696   -16048.696   -16124.305   -16124.305    292.61476    292.61476    36415.473    36415.473    383.27687    383.27687 
Loop time of 9.68137 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.924 ns/day, 2.689 hours/ns, 103.291 timesteps/s
100.0% 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.4908     | 9.4908     | 9.4908     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032335   | 0.032335   | 0.032335   |   0.0 |  0.33
Output  | 5.54e-05   | 5.54e-05   | 5.54e-05   |   0.0 |  0.00
Modify  | 0.13948    | 0.13948    | 0.13948    |   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:      223250.0 ave      223250 max      223250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223250
Ave neighs/atom = 111.62500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.719788182543, Press = -0.24158551018595
next a
jump SELF top
variable a loop 2000
run 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   -16048.696   -16048.696   -16124.305   -16124.305    292.61476    292.61476    36415.473    36415.473    383.27687    383.27687 
   46000   -16047.621   -16047.621   -16125.181   -16125.181     300.1653     300.1653    36404.185    36404.185    753.75409    753.75409 
Loop time of 9.68869 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.918 ns/day, 2.691 hours/ns, 103.213 timesteps/s
100.0% 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.4982     | 9.4982     | 9.4982     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032278   | 0.032278   | 0.032278   |   0.0 |  0.33
Output  | 5.7034e-05 | 5.7034e-05 | 5.7034e-05 |   0.0 |  0.00
Modify  | 0.13951    | 0.13951    | 0.13951    |   0.0 |  1.44
Other   |            | 0.01869    |            |       |  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:      223156.0 ave      223156 max      223156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223156
Ave neighs/atom = 111.57800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.707272525145, Press = -0.673114424168976
next a
jump SELF top
variable a loop 2000
run 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   -16047.621   -16047.621   -16125.181   -16125.181     300.1653     300.1653    36404.185    36404.185    753.75409    753.75409 
   47000   -16047.254   -16047.254   -16124.085   -16124.085    297.34454    297.34454    36450.303    36450.303   -1337.2295   -1337.2295 
Loop time of 9.68543 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.921 ns/day, 2.690 hours/ns, 103.248 timesteps/s
100.0% 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.4948     | 9.4948     | 9.4948     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032362   | 0.032362   | 0.032362   |   0.0 |  0.33
Output  | 5.6804e-05 | 5.6804e-05 | 5.6804e-05 |   0.0 |  0.00
Modify  | 0.13948    | 0.13948    | 0.13948    |   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:      223214.0 ave      223214 max      223214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223214
Ave neighs/atom = 111.60700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.676305716153, Press = -1.25413667514981
next a
jump SELF top
variable a loop 2000
run 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   -16047.254   -16047.254   -16124.085   -16124.085    297.34454    297.34454    36450.303    36450.303   -1337.2295   -1337.2295 
   48000   -16052.483   -16052.483   -16126.853   -16126.853    287.81913    287.81913    36471.314    36471.314   -3120.4417   -3120.4417 
Loop time of 9.68717 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.919 ns/day, 2.691 hours/ns, 103.229 timesteps/s
100.0% 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.4965     | 9.4965     | 9.4965     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032336   | 0.032336   | 0.032336   |   0.0 |  0.33
Output  | 5.6904e-05 | 5.6904e-05 | 5.6904e-05 |   0.0 |  0.00
Modify  | 0.13955    | 0.13955    | 0.13955    |   0.0 |  1.44
Other   |            | 0.01874    |            |       |  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:      223146.0 ave      223146 max      223146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223146
Ave neighs/atom = 111.57300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.609192996684, Press = -1.39506864852493
next a
jump SELF top
variable a loop 2000
run 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   -16052.483   -16052.483   -16126.853   -16126.853    287.81913    287.81913    36471.314    36471.314   -3120.4417   -3120.4417 
   49000   -16046.064   -16046.064   -16123.481   -16123.481    299.61009    299.61009    36425.278    36425.278   0.46966876   0.46966876 
Loop time of 9.6532 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.950 ns/day, 2.681 hours/ns, 103.593 timesteps/s
100.0% 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.4627     | 9.4627     | 9.4627     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03244    | 0.03244    | 0.03244    |   0.0 |  0.34
Output  | 5.4155e-05 | 5.4155e-05 | 5.4155e-05 |   0.0 |  0.00
Modify  | 0.13933    | 0.13933    | 0.13933    |   0.0 |  1.44
Other   |            | 0.01869    |            |       |  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:      223186.0 ave      223186 max      223186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223186
Ave neighs/atom = 111.59300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.59039897163, Press = -0.598437219555921
next a
jump SELF top
variable a loop 2000
run 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   -16046.064   -16046.064   -16123.481   -16123.481    299.61009    299.61009    36425.278    36425.278   0.46966876   0.46966876 
   50000   -16050.554   -16050.554   -16125.218   -16125.218    288.95892    288.95892    36403.382    36403.382     1017.335     1017.335 
Loop time of 9.66955 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.935 ns/day, 2.686 hours/ns, 103.417 timesteps/s
100.0% 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.4795     | 9.4795     | 9.4795     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03228    | 0.03228    | 0.03228    |   0.0 |  0.33
Output  | 7.9164e-05 | 7.9164e-05 | 7.9164e-05 |   0.0 |  0.00
Modify  | 0.13913    | 0.13913    | 0.13913    |   0.0 |  1.44
Other   |            | 0.01858    |            |       |  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:      223088.0 ave      223088 max      223088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223088
Ave neighs/atom = 111.54400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.536539121714, Press = -0.601962083585304
next a
jump SELF top
variable a loop 2000
run 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   -16050.554   -16050.554   -16125.218   -16125.218    288.95892    288.95892    36403.382    36403.382     1017.335     1017.335 
   51000    -16046.49    -16046.49   -16123.276   -16123.276    297.17036    297.17036    36440.723    36440.723   -812.22053   -812.22053 
Loop time of 9.66677 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.938 ns/day, 2.685 hours/ns, 103.447 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.4763     | 9.4763     | 9.4763     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032332   | 0.032332   | 0.032332   |   0.0 |  0.33
Output  | 5.6789e-05 | 5.6789e-05 | 5.6789e-05 |   0.0 |  0.00
Modify  | 0.13939    | 0.13939    | 0.13939    |   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:      223198.0 ave      223198 max      223198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223198
Ave neighs/atom = 111.59900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.561645511343, Press = 0.385196191903343
next a
jump SELF top
variable a loop 2000
run 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    -16046.49    -16046.49   -16123.276   -16123.276    297.17036    297.17036    36440.723    36440.723   -812.22053   -812.22053 
   52000   -16048.648   -16048.648   -16125.747   -16125.747    298.38372    298.38372     36416.77     36416.77    78.772969    78.772969 
Loop time of 9.66173 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.943 ns/day, 2.684 hours/ns, 103.501 timesteps/s
100.0% 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.4714     | 9.4714     | 9.4714     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032287   | 0.032287   | 0.032287   |   0.0 |  0.33
Output  | 5.4259e-05 | 5.4259e-05 | 5.4259e-05 |   0.0 |  0.00
Modify  | 0.13939    | 0.13939    | 0.13939    |   0.0 |  1.44
Other   |            | 0.01864    |            |       |  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:      223096.0 ave      223096 max      223096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223096
Ave neighs/atom = 111.54800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.551798922489, Press = -0.163049254047498
next a
jump SELF top
variable a loop 2000
run 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   -16048.648   -16048.648   -16125.747   -16125.747    298.38372    298.38372     36416.77     36416.77    78.772969    78.772969 
   53000   -16046.383   -16046.383   -16124.265   -16124.265    301.41103    301.41103    36413.278    36413.278     554.9502     554.9502 
Loop time of 9.68029 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.925 ns/day, 2.689 hours/ns, 103.303 timesteps/s
100.0% 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.4899     | 9.4899     | 9.4899     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032422   | 0.032422   | 0.032422   |   0.0 |  0.33
Output  | 5.6256e-05 | 5.6256e-05 | 5.6256e-05 |   0.0 |  0.00
Modify  | 0.13934    | 0.13934    | 0.13934    |   0.0 |  1.44
Other   |            | 0.01857    |            |       |  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:      223194.0 ave      223194 max      223194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223194
Ave neighs/atom = 111.59700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.618064767519, Press = -0.467953267351323
next a
jump SELF top
variable a loop 2000
run 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   -16046.383   -16046.383   -16124.265   -16124.265    301.41103    301.41103    36413.278    36413.278     554.9502     554.9502 
   54000   -16053.865   -16053.865   -16128.329   -16128.329    288.18303    288.18303    36416.504    36416.504   -913.43599   -913.43599 
Loop time of 9.67978 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.926 ns/day, 2.689 hours/ns, 103.308 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.4889     | 9.4889     | 9.4889     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032625   | 0.032625   | 0.032625   |   0.0 |  0.34
Output  | 5.3698e-05 | 5.3698e-05 | 5.3698e-05 |   0.0 |  0.00
Modify  | 0.13952    | 0.13952    | 0.13952    |   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:      223082.0 ave      223082 max      223082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223082
Ave neighs/atom = 111.54100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.584440307373, Press = -0.397600475523154
next a
jump SELF top
variable a loop 2000
run 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   -16053.865   -16053.865   -16128.329   -16128.329    288.18303    288.18303    36416.504    36416.504   -913.43599   -913.43599 
   55000   -16047.091   -16047.091   -16122.688   -16122.688    292.56752    292.56752    36415.646    36415.646     934.9969     934.9969 
Loop time of 9.65672 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.947 ns/day, 2.682 hours/ns, 103.555 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.4662     | 9.4662     | 9.4662     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032453   | 0.032453   | 0.032453   |   0.0 |  0.34
Output  | 5.4994e-05 | 5.4994e-05 | 5.4994e-05 |   0.0 |  0.00
Modify  | 0.13922    | 0.13922    | 0.13922    |   0.0 |  1.44
Other   |            | 0.01876    |            |       |  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:      223208.0 ave      223208 max      223208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223208
Ave neighs/atom = 111.60400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.542523632835, Press = -0.0438052486615433
next a
jump SELF top
variable a loop 2000
run 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   -16047.091   -16047.091   -16122.688   -16122.688    292.56752    292.56752    36415.646    36415.646     934.9969     934.9969 
   56000   -16047.605   -16047.605   -16121.395   -16121.395    285.57495    285.57495    36432.987    36432.987   -60.309292   -60.309292 
Loop time of 9.66283 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.941 ns/day, 2.684 hours/ns, 103.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.4724     | 9.4724     | 9.4724     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032347   | 0.032347   | 0.032347   |   0.0 |  0.33
Output  | 7.6922e-05 | 7.6922e-05 | 7.6922e-05 |   0.0 |  0.00
Modify  | 0.13933    | 0.13933    | 0.13933    |   0.0 |  1.44
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:      223110.0 ave      223110 max      223110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223110
Ave neighs/atom = 111.55500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.508716969251, Press = -1.08474233366866
next a
jump SELF top
variable a loop 2000
run 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   -16047.605   -16047.605   -16121.395   -16121.395    285.57495    285.57495    36432.987    36432.987   -60.309292   -60.309292 
   57000   -16049.209   -16049.209   -16123.375   -16123.375    287.03195    287.03195    36414.224    36414.224     694.2083     694.2083 
Loop time of 9.66183 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.942 ns/day, 2.684 hours/ns, 103.500 timesteps/s
100.0% 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.4713     | 9.4713     | 9.4713     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032367   | 0.032367   | 0.032367   |   0.0 |  0.33
Output  | 5.5517e-05 | 5.5517e-05 | 5.5517e-05 |   0.0 |  0.00
Modify  | 0.13948    | 0.13948    | 0.13948    |   0.0 |  1.44
Other   |            | 0.01864    |            |       |  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:      223012.0 ave      223012 max      223012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223012
Ave neighs/atom = 111.50600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.513885211537, Press = -1.14305801157303
next a
jump SELF top
variable a loop 2000
run 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   -16049.209   -16049.209   -16123.375   -16123.375    287.03195    287.03195    36414.224    36414.224     694.2083     694.2083 
   58000   -16046.289   -16046.289   -16124.114   -16124.114    301.19327    301.19327    36409.036    36409.036    897.84624    897.84624 
Loop time of 9.79801 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.818 ns/day, 2.722 hours/ns, 102.062 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6011     | 9.6011     | 9.6011     |   0.0 | 97.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.033089   | 0.033089   | 0.033089   |   0.0 |  0.34
Output  | 5.6374e-05 | 5.6374e-05 | 5.6374e-05 |   0.0 |  0.00
Modify  | 0.14381    | 0.14381    | 0.14381    |   0.0 |  1.47
Other   |            | 0.02       |            |       |  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:      223076.0 ave      223076 max      223076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223076
Ave neighs/atom = 111.53800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.521664310342, Press = -1.01407176782166
next a
jump SELF top
variable a loop 2000
run 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   -16046.289   -16046.289   -16124.114   -16124.114    301.19327    301.19327    36409.036    36409.036    897.84624    897.84624 
   59000   -16050.019   -16050.019   -16125.347   -16125.347    291.52962    291.52962    36411.121    36411.121    271.87627    271.87627 
Loop time of 9.81574 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.802 ns/day, 2.727 hours/ns, 101.877 timesteps/s
100.0% 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.6203     | 9.6203     | 9.6203     |   0.0 | 98.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032902   | 0.032902   | 0.032902   |   0.0 |  0.34
Output  | 5.7068e-05 | 5.7068e-05 | 5.7068e-05 |   0.0 |  0.00
Modify  | 0.14304    | 0.14304    | 0.14304    |   0.0 |  1.46
Other   |            | 0.01941    |            |       |  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:      223100.0 ave      223100 max      223100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223100
Ave neighs/atom = 111.55000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.55527084949, Press = -0.115435681744802
next a
jump SELF top
variable a loop 2000
run 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   -16050.019   -16050.019   -16125.347   -16125.347    291.52962    291.52962    36411.121    36411.121    271.87627    271.87627 
   60000    -16046.75    -16046.75   -16122.117   -16122.117    291.67511    291.67511    36453.226    36453.226   -1346.0273   -1346.0273 
Loop time of 9.80335 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.813 ns/day, 2.723 hours/ns, 102.006 timesteps/s
100.0% 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.6086     | 9.6086     | 9.6086     |   0.0 | 98.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032998   | 0.032998   | 0.032998   |   0.0 |  0.34
Output  | 5.8664e-05 | 5.8664e-05 | 5.8664e-05 |   0.0 |  0.00
Modify  | 0.1424     | 0.1424     | 0.1424     |   0.0 |  1.45
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:      223222.0 ave      223222 max      223222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223222
Ave neighs/atom = 111.61100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.53417827898, Press = -0.215164920710356
next a
jump SELF top
variable a loop 2000
run 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    -16046.75    -16046.75   -16122.117   -16122.117    291.67511    291.67511    36453.226    36453.226   -1346.0273   -1346.0273 
   61000   -16049.116   -16049.116   -16124.229   -16124.229    290.69348    290.69348     36442.15     36442.15   -1251.3263   -1251.3263 
Loop time of 9.77726 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.837 ns/day, 2.716 hours/ns, 102.278 timesteps/s
100.0% 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.583      | 9.583      | 9.583      |   0.0 | 98.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032785   | 0.032785   | 0.032785   |   0.0 |  0.34
Output  | 5.6666e-05 | 5.6666e-05 | 5.6666e-05 |   0.0 |  0.00
Modify  | 0.14229    | 0.14229    | 0.14229    |   0.0 |  1.46
Other   |            | 0.01912    |            |       |  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:      223092.0 ave      223092 max      223092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223092
Ave neighs/atom = 111.54600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.525084079959, Press = -0.388056034804088
next a
jump SELF top
variable a loop 2000
run 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   -16049.116   -16049.116   -16124.229   -16124.229    290.69348    290.69348     36442.15     36442.15   -1251.3263   -1251.3263 
   62000   -16047.962   -16047.962   -16122.782   -16122.782    289.56086    289.56086    36412.606    36412.606    961.57259    961.57259 
Loop time of 9.80737 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.810 ns/day, 2.724 hours/ns, 101.964 timesteps/s
100.0% 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.6099     | 9.6099     | 9.6099     |   0.0 | 97.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.033205   | 0.033205   | 0.033205   |   0.0 |  0.34
Output  | 8.3853e-05 | 8.3853e-05 | 8.3853e-05 |   0.0 |  0.00
Modify  | 0.14415    | 0.14415    | 0.14415    |   0.0 |  1.47
Other   |            | 0.02002    |            |       |  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:      223086.0 ave      223086 max      223086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223086
Ave neighs/atom = 111.54300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.505742535222, Press = -1.0995500073229
next a
jump SELF top
variable a loop 2000
run 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   -16047.962   -16047.962   -16122.782   -16122.782    289.56086    289.56086    36412.606    36412.606    961.57259    961.57259 
   63000   -16050.424   -16050.424   -16124.671   -16124.671    287.34107    287.34107    36441.356    36441.356   -1046.0563   -1046.0563 
Loop time of 9.74913 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.862 ns/day, 2.708 hours/ns, 102.573 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5544     | 9.5544     | 9.5544     |   0.0 | 98.00
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032774   | 0.032774   | 0.032774   |   0.0 |  0.34
Output  | 5.7135e-05 | 5.7135e-05 | 5.7135e-05 |   0.0 |  0.00
Modify  | 0.14244    | 0.14244    | 0.14244    |   0.0 |  1.46
Other   |            | 0.01949    |            |       |  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:      223168.0 ave      223168 max      223168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223168
Ave neighs/atom = 111.58400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.491484576361, Press = -0.550520568709348
next a
jump SELF top
variable a loop 2000
run 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   -16050.424   -16050.424   -16124.671   -16124.671    287.34107    287.34107    36441.356    36441.356   -1046.0563   -1046.0563 
   64000    -16047.66    -16047.66   -16125.447   -16125.447    301.04236    301.04236    36435.329    36435.329   -745.80869   -745.80869 
Loop time of 9.74698 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.864 ns/day, 2.707 hours/ns, 102.596 timesteps/s
100.0% 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.5537     | 9.5537     | 9.5537     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032675   | 0.032675   | 0.032675   |   0.0 |  0.34
Output  | 5.4755e-05 | 5.4755e-05 | 5.4755e-05 |   0.0 |  0.00
Modify  | 0.14129    | 0.14129    | 0.14129    |   0.0 |  1.45
Other   |            | 0.0193     |            |       |  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:      223162.0 ave      223162 max      223162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223162
Ave neighs/atom = 111.58100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.481844048932, Press = -1.13263248629055
next a
jump SELF top
variable a loop 2000
run 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    -16047.66    -16047.66   -16125.447   -16125.447    301.04236    301.04236    36435.329    36435.329   -745.80869   -745.80869 
   65000   -16049.671   -16049.671   -16126.487   -16126.487    297.28776    297.28776    36438.119    36438.119    -1299.099    -1299.099 
Loop time of 9.70305 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.904 ns/day, 2.695 hours/ns, 103.060 timesteps/s
100.0% 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.5115     | 9.5115     | 9.5115     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03243    | 0.03243    | 0.03243    |   0.0 |  0.33
Output  | 5.53e-05   | 5.53e-05   | 5.53e-05   |   0.0 |  0.00
Modify  | 0.1402     | 0.1402     | 0.1402     |   0.0 |  1.44
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:      223246.0 ave      223246 max      223246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223246
Ave neighs/atom = 111.62300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.492840258293, Press = -0.58061117526937
next a
jump SELF top
variable a loop 2000
run 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   -16049.671   -16049.671   -16126.487   -16126.487    297.28776    297.28776    36438.119    36438.119    -1299.099    -1299.099 
   66000   -16050.971   -16050.971   -16126.631   -16126.631    292.81462    292.81462    36416.686    36416.686   -285.98898   -285.98898 
Loop time of 9.71353 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.895 ns/day, 2.698 hours/ns, 102.949 timesteps/s
100.0% 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.522      | 9.522      | 9.522      |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03258    | 0.03258    | 0.03258    |   0.0 |  0.34
Output  | 5.387e-05  | 5.387e-05  | 5.387e-05  |   0.0 |  0.00
Modify  | 0.14001    | 0.14001    | 0.14001    |   0.0 |  1.44
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:      223236.0 ave      223236 max      223236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223236
Ave neighs/atom = 111.61800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.478041128318, Press = -1.22021991426066
next a
jump SELF top
variable a loop 2000
run 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   -16050.971   -16050.971   -16126.631   -16126.631    292.81462    292.81462    36416.686    36416.686   -285.98898   -285.98898 
   67000   -16042.893   -16042.893   -16122.828   -16122.828    309.35754    309.35754    36460.315    36460.315   -1505.7472   -1505.7472 
Loop time of 9.69787 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.909 ns/day, 2.694 hours/ns, 103.115 timesteps/s
100.0% 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.5064     | 9.5064     | 9.5064     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032441   | 0.032441   | 0.032441   |   0.0 |  0.33
Output  | 5.573e-05  | 5.573e-05  | 5.573e-05  |   0.0 |  0.00
Modify  | 0.1402     | 0.1402     | 0.1402     |   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:      223236.0 ave      223236 max      223236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223236
Ave neighs/atom = 111.61800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.495544437867, Press = -0.617336470686457
next a
jump SELF top
variable a loop 2000
run 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   -16042.893   -16042.893   -16122.828   -16122.828    309.35754    309.35754    36460.315    36460.315   -1505.7472   -1505.7472 
   68000       -16050       -16050   -16124.157   -16124.157    286.99481    286.99481    36422.647    36422.647    358.62914    358.62914 
Loop time of 9.68953 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.917 ns/day, 2.692 hours/ns, 103.204 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.4979     | 9.4979     | 9.4979     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032529   | 0.032529   | 0.032529   |   0.0 |  0.34
Output  | 7.8769e-05 | 7.8769e-05 | 7.8769e-05 |   0.0 |  0.00
Modify  | 0.14018    | 0.14018    | 0.14018    |   0.0 |  1.45
Other   |            | 0.01887    |            |       |  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:      223070.0 ave      223070 max      223070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223070
Ave neighs/atom = 111.53500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.513911521792, Press = -1.31084772555176
next a
jump SELF top
variable a loop 2000
run 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       -16050       -16050   -16124.157   -16124.157    286.99481    286.99481    36422.647    36422.647    358.62914    358.62914 
   69000   -16049.922   -16049.922   -16123.782   -16123.782    285.84745    285.84745    36417.274    36417.274    307.23688    307.23688 
Loop time of 9.72508 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.884 ns/day, 2.701 hours/ns, 102.827 timesteps/s
100.0% 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.5318     | 9.5318     | 9.5318     |   0.0 | 98.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032661   | 0.032661   | 0.032661   |   0.0 |  0.34
Output  | 5.5093e-05 | 5.5093e-05 | 5.5093e-05 |   0.0 |  0.00
Modify  | 0.14151    | 0.14151    | 0.14151    |   0.0 |  1.46
Other   |            | 0.01908    |            |       |  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:      223216.0 ave      223216 max      223216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223216
Ave neighs/atom = 111.60800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.507067742753, Press = -1.18576591136061
next a
jump SELF top
variable a loop 2000
run 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   -16049.922   -16049.922   -16123.782   -16123.782    285.84745    285.84745    36417.274    36417.274    307.23688    307.23688 
   70000   -16047.927   -16047.927   -16124.214   -16124.214    295.23914    295.23914    36388.583    36388.583    2111.5035    2111.5035 
Loop time of 9.71921 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.890 ns/day, 2.700 hours/ns, 102.889 timesteps/s
100.0% 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.5281     | 9.5281     | 9.5281     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032315   | 0.032315   | 0.032315   |   0.0 |  0.33
Output  | 5.7068e-05 | 5.7068e-05 | 5.7068e-05 |   0.0 |  0.00
Modify  | 0.14002    | 0.14002    | 0.14002    |   0.0 |  1.44
Other   |            | 0.01875    |            |       |  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:      223180.0 ave      223180 max      223180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223180
Ave neighs/atom = 111.59000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.495064902683, Press = 0.0564707899644436
next a
jump SELF top
variable a loop 2000
run 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   -16047.927   -16047.927   -16124.214   -16124.214    295.23914    295.23914    36388.583    36388.583    2111.5035    2111.5035 
   71000   -16048.669   -16048.669    -16125.95    -16125.95    299.08558    299.08558    36419.524    36419.524   -108.70476   -108.70476 
Loop time of 9.68782 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.918 ns/day, 2.691 hours/ns, 103.222 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.4966     | 9.4966     | 9.4966     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032447   | 0.032447   | 0.032447   |   0.0 |  0.33
Output  | 6.7667e-05 | 6.7667e-05 | 6.7667e-05 |   0.0 |  0.00
Modify  | 0.1399     | 0.1399     | 0.1399     |   0.0 |  1.44
Other   |            | 0.0188     |            |       |  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:      223200.0 ave      223200 max      223200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223200
Ave neighs/atom = 111.60000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.516797259996, Press = -0.4661701138444
next a
jump SELF top
variable a loop 2000
run 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   -16048.669   -16048.669    -16125.95    -16125.95    299.08558    299.08558    36419.524    36419.524   -108.70476   -108.70476 
   72000   -16051.013   -16051.013     -16126.6     -16126.6    292.53112    292.53112    36446.236    36446.236   -1629.3568   -1629.3568 
Loop time of 9.71155 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.897 ns/day, 2.698 hours/ns, 102.970 timesteps/s
100.0% 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.52       | 9.52       | 9.52       |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03264    | 0.03264    | 0.03264    |   0.0 |  0.34
Output  | 5.7248e-05 | 5.7248e-05 | 5.7248e-05 |   0.0 |  0.00
Modify  | 0.14019    | 0.14019    | 0.14019    |   0.0 |  1.44
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:      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 = 293.519531626256, Press = -0.734478957902563
next a
jump SELF top
variable a loop 2000
run 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   -16051.013   -16051.013     -16126.6     -16126.6    292.53112    292.53112    36446.236    36446.236   -1629.3568   -1629.3568 
   73000   -16049.941   -16049.941   -16124.844   -16124.844    289.88556    289.88556    36417.694    36417.694    252.62347    252.62347 
Loop time of 9.69416 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.913 ns/day, 2.693 hours/ns, 103.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.5027     | 9.5027     | 9.5027     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032424   | 0.032424   | 0.032424   |   0.0 |  0.33
Output  | 5.5301e-05 | 5.5301e-05 | 5.5301e-05 |   0.0 |  0.00
Modify  | 0.14015    | 0.14015    | 0.14015    |   0.0 |  1.45
Other   |            | 0.01887    |            |       |  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:      223214.0 ave      223214 max      223214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223214
Ave neighs/atom = 111.60700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.528022859258, Press = -0.408892566472465
next a
jump SELF top
variable a loop 2000
run 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   -16049.941   -16049.941   -16124.844   -16124.844    289.88556    289.88556    36417.694    36417.694    252.62347    252.62347 
   74000   -16046.692   -16046.692   -16123.326   -16123.326    296.58308    296.58308     36423.27     36423.27    178.80837    178.80837 
Loop time of 9.71263 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.5212     | 9.5212     | 9.5212     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0324     | 0.0324     | 0.0324     |   0.0 |  0.33
Output  | 8.5557e-05 | 8.5557e-05 | 8.5557e-05 |   0.0 |  0.00
Modify  | 0.14007    | 0.14007    | 0.14007    |   0.0 |  1.44
Other   |            | 0.01883    |            |       |  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:      223204.0 ave      223204 max      223204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223204
Ave neighs/atom = 111.60200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.532793140134, Press = -0.105659244994371
next a
jump SELF top
variable a loop 2000
run 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   -16046.692   -16046.692   -16123.326   -16123.326    296.58308    296.58308     36423.27     36423.27    178.80837    178.80837 
   75000   -16051.063   -16051.063   -16126.279   -16126.279    291.09401    291.09401    36397.876    36397.876     819.8574     819.8574 
Loop time of 9.72724 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.882 ns/day, 2.702 hours/ns, 102.804 timesteps/s
100.0% 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.5348     | 9.5348     | 9.5348     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032525   | 0.032525   | 0.032525   |   0.0 |  0.33
Output  | 6.5221e-05 | 6.5221e-05 | 6.5221e-05 |   0.0 |  0.00
Modify  | 0.14095    | 0.14095    | 0.14095    |   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:      223106.0 ave      223106 max      223106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223106
Ave neighs/atom = 111.55300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.510235813839, Press = -0.88466893284569
next a
jump SELF top
variable a loop 2000
run 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 
   75000   -16051.063   -16051.063   -16126.279   -16126.279    291.09401    291.09401    36397.876    36397.876     819.8574     819.8574 
   76000   -16048.676   -16048.676   -16125.588   -16125.588    297.65889    297.65889    36377.973    36377.973    2232.1779    2232.1779 
Loop time of 9.69269 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.914 ns/day, 2.692 hours/ns, 103.170 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5017     | 9.5017     | 9.5017     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032422   | 0.032422   | 0.032422   |   0.0 |  0.33
Output  | 6.5073e-05 | 6.5073e-05 | 6.5073e-05 |   0.0 |  0.00
Modify  | 0.13965    | 0.13965    | 0.13965    |   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:      223178.0 ave      223178 max      223178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223178
Ave neighs/atom = 111.58900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.503689874745, Press = -0.493832890462868
next a
jump SELF top
variable a loop 2000
run 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 
   76000   -16048.676   -16048.676   -16125.588   -16125.588    297.65889    297.65889    36377.973    36377.973    2232.1779    2232.1779 
   77000   -16051.502   -16051.502   -16125.528   -16125.528    286.48886    286.48886    36390.506    36390.506    1506.3784    1506.3784 
Loop time of 9.88097 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.744 ns/day, 2.745 hours/ns, 101.205 timesteps/s
100.0% 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.6824     | 9.6824     | 9.6824     |   0.0 | 97.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.033267   | 0.033267   | 0.033267   |   0.0 |  0.34
Output  | 6.5274e-05 | 6.5274e-05 | 6.5274e-05 |   0.0 |  0.00
Modify  | 0.14553    | 0.14553    | 0.14553    |   0.0 |  1.47
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:      223198.0 ave      223198 max      223198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223198
Ave neighs/atom = 111.59900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.472499434294, Press = -0.250515544659377
next a
jump SELF top
variable a loop 2000
run 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 
   77000   -16051.502   -16051.502   -16125.528   -16125.528    286.48886    286.48886    36390.506    36390.506    1506.3784    1506.3784 
   78000   -16046.702   -16046.702   -16123.727   -16123.727    298.09838    298.09838    36436.407    36436.407   -515.46207   -515.46207 
Loop time of 9.69461 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.912 ns/day, 2.693 hours/ns, 103.150 timesteps/s
100.0% 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.5036     | 9.5036     | 9.5036     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032322   | 0.032322   | 0.032322   |   0.0 |  0.33
Output  | 7.2391e-05 | 7.2391e-05 | 7.2391e-05 |   0.0 |  0.00
Modify  | 0.13976    | 0.13976    | 0.13976    |   0.0 |  1.44
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:      223240.0 ave      223240 max      223240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223240
Ave neighs/atom = 111.62000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.452158197442, Press = -0.0586013760089111
next a
jump SELF top
variable a loop 2000
run 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 
   78000   -16046.702   -16046.702   -16123.727   -16123.727    298.09838    298.09838    36436.407    36436.407   -515.46207   -515.46207 
   79000   -16046.473   -16046.473   -16123.246   -16123.246    297.11938    297.11938    36413.187    36413.187    1107.7247    1107.7247 
Loop time of 9.67601 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.929 ns/day, 2.688 hours/ns, 103.348 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.4849     | 9.4849     | 9.4849     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032505   | 0.032505   | 0.032505   |   0.0 |  0.34
Output  | 6.5942e-05 | 6.5942e-05 | 6.5942e-05 |   0.0 |  0.00
Modify  | 0.13974    | 0.13974    | 0.13974    |   0.0 |  1.44
Other   |            | 0.01878    |            |       |  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:      223114.0 ave      223114 max      223114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223114
Ave neighs/atom = 111.55700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.44580377073, Press = -0.782186773613692
next a
jump SELF top
variable a loop 2000
run 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 
   79000   -16046.473   -16046.473   -16123.246   -16123.246    297.11938    297.11938    36413.187    36413.187    1107.7247    1107.7247 
   80000   -16050.271   -16050.271   -16126.646   -16126.646    295.57996    295.57996    36373.327    36373.327    2516.2639    2516.2639 
Loop time of 9.69135 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.915 ns/day, 2.692 hours/ns, 103.185 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5        | 9.5        | 9.5        |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032392   | 0.032392   | 0.032392   |   0.0 |  0.33
Output  | 8.0907e-05 | 8.0907e-05 | 8.0907e-05 |   0.0 |  0.00
Modify  | 0.13995    | 0.13995    | 0.13995    |   0.0 |  1.44
Other   |            | 0.0189     |            |       |  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:      223174.0 ave      223174 max      223174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223174
Ave neighs/atom = 111.58700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.460672530044, Press = -0.521568305599132
next a
jump SELF top
variable a loop 2000
run 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 
   80000   -16050.271   -16050.271   -16126.646   -16126.646    295.57996    295.57996    36373.327    36373.327    2516.2639    2516.2639 
   81000   -16048.851   -16048.851   -16125.402   -16125.402    296.25789    296.25789     36371.63     36371.63    2711.5217    2711.5217 
Loop time of 9.75529 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.857 ns/day, 2.710 hours/ns, 102.509 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5609     | 9.5609     | 9.5609     |   0.0 | 98.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032903   | 0.032903   | 0.032903   |   0.0 |  0.34
Output  | 8.3666e-05 | 8.3666e-05 | 8.3666e-05 |   0.0 |  0.00
Modify  | 0.14188    | 0.14188    | 0.14188    |   0.0 |  1.45
Other   |            | 0.01955    |            |       |  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:      223360.0 ave      223360 max      223360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223360
Ave neighs/atom = 111.68000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.440153242985, Press = -0.157272070375701
next a
jump SELF top
variable a loop 2000
run 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 
   81000   -16048.851   -16048.851   -16125.402   -16125.402    296.25789    296.25789     36371.63     36371.63    2711.5217    2711.5217 
   82000   -16049.261   -16049.261   -16125.312   -16125.312     294.3233     294.3233    36411.535    36411.535    910.14433    910.14433 
Loop time of 9.69513 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.912 ns/day, 2.693 hours/ns, 103.145 timesteps/s
100.0% 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.5037     | 9.5037     | 9.5037     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032431   | 0.032431   | 0.032431   |   0.0 |  0.33
Output  | 0.00012978 | 0.00012978 | 0.00012978 |   0.0 |  0.00
Modify  | 0.14023    | 0.14023    | 0.14023    |   0.0 |  1.45
Other   |            | 0.01859    |            |       |  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:      223262.0 ave      223262 max      223262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223262
Ave neighs/atom = 111.63100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.439291483871, Press = -0.401526498251483
next a
jump SELF top
variable a loop 2000
run 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 
   82000   -16049.261   -16049.261   -16125.312   -16125.312     294.3233     294.3233    36411.535    36411.535    910.14433    910.14433 
   83000   -16047.936   -16047.936   -16124.526   -16124.526    296.41029    296.41029    36394.585    36394.585     1459.773     1459.773 
Loop time of 9.70195 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.905 ns/day, 2.695 hours/ns, 103.072 timesteps/s
100.0% 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.5106     | 9.5106     | 9.5106     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032572   | 0.032572   | 0.032572   |   0.0 |  0.34
Output  | 8.3639e-05 | 8.3639e-05 | 8.3639e-05 |   0.0 |  0.00
Modify  | 0.13974    | 0.13974    | 0.13974    |   0.0 |  1.44
Other   |            | 0.01891    |            |       |  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:      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 = 293.413829252601, Press = -0.569253764083667
next a
jump SELF top
variable a loop 2000
run 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 
   83000   -16047.936   -16047.936   -16124.526   -16124.526    296.41029    296.41029    36394.585    36394.585     1459.773     1459.773 
   84000   -16050.372   -16050.372   -16124.874   -16124.874    288.33016    288.33016    36411.259    36411.259    621.03353    621.03353 
Loop time of 9.69034 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.916 ns/day, 2.692 hours/ns, 103.196 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.4991     | 9.4991     | 9.4991     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032481   | 0.032481   | 0.032481   |   0.0 |  0.34
Output  | 8.3351e-05 | 8.3351e-05 | 8.3351e-05 |   0.0 |  0.00
Modify  | 0.13991    | 0.13991    | 0.13991    |   0.0 |  1.44
Other   |            | 0.01873    |            |       |  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:      223190.0 ave      223190 max      223190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223190
Ave neighs/atom = 111.59500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.401246285107, Press = -0.864852197826715
next a
jump SELF top
variable a loop 2000
run 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 
   84000   -16050.372   -16050.372   -16124.874   -16124.874    288.33016    288.33016    36411.259    36411.259    621.03353    621.03353 
   85000   -16047.296   -16047.296   -16122.959   -16122.959     292.8221     292.8221    36456.213    36456.213   -1517.9026   -1517.9026 
Loop time of 9.69047 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.916 ns/day, 2.692 hours/ns, 103.194 timesteps/s
100.0% 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.4999     | 9.4999     | 9.4999     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032382   | 0.032382   | 0.032382   |   0.0 |  0.33
Output  | 6.0994e-05 | 6.0994e-05 | 6.0994e-05 |   0.0 |  0.00
Modify  | 0.13931    | 0.13931    | 0.13931    |   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:      223238.0 ave      223238 max      223238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223238
Ave neighs/atom = 111.61900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.399913884605, Press = -0.28533737918054
next a
jump SELF top
variable a loop 2000
run 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 
   85000   -16047.296   -16047.296   -16122.959   -16122.959     292.8221     292.8221    36456.213    36456.213   -1517.9026   -1517.9026 
   86000   -16051.671   -16051.671   -16125.765   -16125.765    286.75315    286.75315    36459.851    36459.851    -2301.972    -2301.972 
Loop time of 10.1281 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.531 ns/day, 2.813 hours/ns, 98.736 timesteps/s
100.0% 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.9188     | 9.9188     | 9.9188     |   0.0 | 97.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034392   | 0.034392   | 0.034392   |   0.0 |  0.34
Output  | 9.2588e-05 | 9.2588e-05 | 9.2588e-05 |   0.0 |  0.00
Modify  | 0.154      | 0.154      | 0.154      |   0.0 |  1.52
Other   |            | 0.02079    |            |       |  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:      223102.0 ave      223102 max      223102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223102
Ave neighs/atom = 111.55100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.365189870564, Press = -0.630829367452221
next a
jump SELF top
variable a loop 2000
run 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 
   86000   -16051.671   -16051.671   -16125.765   -16125.765    286.75315    286.75315    36459.851    36459.851    -2301.972    -2301.972 
   87000   -16047.479   -16047.479   -16125.143   -16125.143    300.56633    300.56633    36409.725    36409.725    518.83979    518.83979 
Loop time of 9.71849 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.890 ns/day, 2.700 hours/ns, 102.897 timesteps/s
100.0% 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.5267     | 9.5267     | 9.5267     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032577   | 0.032577   | 0.032577   |   0.0 |  0.34
Output  | 0.00013937 | 0.00013937 | 0.00013937 |   0.0 |  0.00
Modify  | 0.14004    | 0.14004    | 0.14004    |   0.0 |  1.44
Other   |            | 0.01898    |            |       |  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:      223218.0 ave      223218 max      223218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223218
Ave neighs/atom = 111.60900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.37048815207, Press = -0.596677307199251
next a
jump SELF top
variable a loop 2000
run 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 
   87000   -16047.479   -16047.479   -16125.143   -16125.143    300.56633    300.56633    36409.725    36409.725    518.83979    518.83979 
   88000   -16048.946   -16048.946   -16124.115   -16124.115    290.91332    290.91332    36429.089    36429.089   -557.24614   -557.24614 
Loop time of 9.66264 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.942 ns/day, 2.684 hours/ns, 103.491 timesteps/s
100.0% 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.4724     | 9.4724     | 9.4724     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032547   | 0.032547   | 0.032547   |   0.0 |  0.34
Output  | 8.5118e-05 | 8.5118e-05 | 8.5118e-05 |   0.0 |  0.00
Modify  | 0.13873    | 0.13873    | 0.13873    |   0.0 |  1.44
Other   |            | 0.01886    |            |       |  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:      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 = 293.379059091657, Press = -1.07334856887913
next a
jump SELF top
variable a loop 2000
run 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 
   88000   -16048.946   -16048.946   -16124.115   -16124.115    290.91332    290.91332    36429.089    36429.089   -557.24614   -557.24614 
   89000   -16048.114   -16048.114   -16123.442   -16123.442    291.52629    291.52629    36407.014    36407.014    1069.9025    1069.9025 
Loop time of 9.71129 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.897 ns/day, 2.698 hours/ns, 102.973 timesteps/s
100.0% 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.5198     | 9.5198     | 9.5198     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032721   | 0.032721   | 0.032721   |   0.0 |  0.34
Output  | 8.2926e-05 | 8.2926e-05 | 8.2926e-05 |   0.0 |  0.00
Modify  | 0.13964    | 0.13964    | 0.13964    |   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:      223158.0 ave      223158 max      223158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223158
Ave neighs/atom = 111.57900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.387838986557, Press = -0.735932173920517
next a
jump SELF top
variable a loop 2000
run 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 
   89000   -16048.114   -16048.114   -16123.442   -16123.442    291.52629    291.52629    36407.014    36407.014    1069.9025    1069.9025 
   90000   -16051.617   -16051.617   -16126.852   -16126.852    291.16861    291.16861    36453.948    36453.948   -2507.4504   -2507.4504 
Loop time of 9.78585 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.829 ns/day, 2.718 hours/ns, 102.188 timesteps/s
100.0% 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.5916     | 9.5916     | 9.5916     |   0.0 | 98.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032904   | 0.032904   | 0.032904   |   0.0 |  0.34
Output  | 6.2459e-05 | 6.2459e-05 | 6.2459e-05 |   0.0 |  0.00
Modify  | 0.14196    | 0.14196    | 0.14196    |   0.0 |  1.45
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:      223202.0 ave      223202 max      223202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223202
Ave neighs/atom = 111.60100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.364079189338, Press = -0.230825070145896
next a
jump SELF top
variable a loop 2000
run 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 
   90000   -16051.617   -16051.617   -16126.852   -16126.852    291.16861    291.16861    36453.948    36453.948   -2507.4504   -2507.4504 
   91000   -16048.638   -16048.638   -16123.468   -16123.468    289.60138    289.60138    36437.853    36437.853   -721.71199   -721.71199 
Loop time of 9.6983 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5063     | 9.5063     | 9.5063     |   0.0 | 98.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032491   | 0.032491   | 0.032491   |   0.0 |  0.34
Output  | 8.2673e-05 | 8.2673e-05 | 8.2673e-05 |   0.0 |  0.00
Modify  | 0.14049    | 0.14049    | 0.14049    |   0.0 |  1.45
Other   |            | 0.01896    |            |       |  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:      223236.0 ave      223236 max      223236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223236
Ave neighs/atom = 111.61800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.346346351638, Press = -0.209283602557486
next a
jump SELF top
variable a loop 2000
run 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 
   91000   -16048.638   -16048.638   -16123.468   -16123.468    289.60138    289.60138    36437.853    36437.853   -721.71199   -721.71199 
   92000   -16047.965   -16047.965   -16123.306   -16123.306     291.5778     291.5778    36441.089    36441.089   -850.09263   -850.09263 
Loop time of 9.69134 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.915 ns/day, 2.692 hours/ns, 103.185 timesteps/s
100.0% 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.5002     | 9.5002     | 9.5002     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032376   | 0.032376   | 0.032376   |   0.0 |  0.33
Output  | 6.3625e-05 | 6.3625e-05 | 6.3625e-05 |   0.0 |  0.00
Modify  | 0.13977    | 0.13977    | 0.13977    |   0.0 |  1.44
Other   |            | 0.0189     |            |       |  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:      223042.0 ave      223042 max      223042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223042
Ave neighs/atom = 111.52100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.323334382147, Press = -0.360893996044888
next a
jump SELF top
variable a loop 2000
run 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 
   92000   -16047.965   -16047.965   -16123.306   -16123.306     291.5778     291.5778    36441.089    36441.089   -850.09263   -850.09263 
   93000   -16053.937   -16053.937   -16127.259   -16127.259    283.76263    283.76263    36399.832    36399.832    289.14397    289.14397 
Loop time of 9.67711 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.928 ns/day, 2.688 hours/ns, 103.337 timesteps/s
100.0% 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.4863     | 9.4863     | 9.4863     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032327   | 0.032327   | 0.032327   |   0.0 |  0.33
Output  | 6.2468e-05 | 6.2468e-05 | 6.2468e-05 |   0.0 |  0.00
Modify  | 0.13958    | 0.13958    | 0.13958    |   0.0 |  1.44
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:      223130.0 ave      223130 max      223130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223130
Ave neighs/atom = 111.56500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.296101012965, Press = -0.234003688236461
next a
jump SELF top
variable a loop 2000
run 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 
   93000   -16053.937   -16053.937   -16127.259   -16127.259    283.76263    283.76263    36399.832    36399.832    289.14397    289.14397 
   94000   -16047.172   -16047.172   -16125.421   -16125.421    302.83519    302.83519    36452.261    36452.261    -1786.247    -1786.247 
Loop time of 9.68468 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.921 ns/day, 2.690 hours/ns, 103.256 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.4938     | 9.4938     | 9.4938     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032348   | 0.032348   | 0.032348   |   0.0 |  0.33
Output  | 6.3339e-05 | 6.3339e-05 | 6.3339e-05 |   0.0 |  0.00
Modify  | 0.13964    | 0.13964    | 0.13964    |   0.0 |  1.44
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:      223262.0 ave      223262 max      223262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223262
Ave neighs/atom = 111.63100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.283406104135, Press = -0.298047732499143
next a
jump SELF top
variable a loop 2000
run 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 
   94000   -16047.172   -16047.172   -16125.421   -16125.421    302.83519    302.83519    36452.261    36452.261    -1786.247    -1786.247 
   95000   -16050.316   -16050.316    -16125.73    -16125.73    291.86037    291.86037    36382.911    36382.911    1760.6556    1760.6556 
Loop time of 9.68203 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.924 ns/day, 2.689 hours/ns, 103.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.4909     | 9.4909     | 9.4909     |   0.0 | 98.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032401   | 0.032401   | 0.032401   |   0.0 |  0.33
Output  | 8.5092e-05 | 8.5092e-05 | 8.5092e-05 |   0.0 |  0.00
Modify  | 0.13972    | 0.13972    | 0.13972    |   0.0 |  1.44
Other   |            | 0.01892    |            |       |  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:      223182.0 ave      223182 max      223182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0