# 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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    -16134.46    -16134.46   -16199.872   -16199.872       253.15       253.15    36064.482    36064.482    1937.3055    1937.3055 
    1000   -16069.446   -16069.446   -16134.054   -16134.054    250.04203    250.04203    36351.092    36351.092    901.21897    901.21897 
Loop time of 12.0086 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.195 ns/day, 3.336 hours/ns, 83.273 timesteps/s
84.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.773     | 11.773     | 11.773     |   0.0 | 98.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034904   | 0.034904   | 0.034904   |   0.0 |  0.29
Output  | 0.00023637 | 0.00023637 | 0.00023637 |   0.0 |  0.00
Modify  | 0.15272    | 0.15272    | 0.15272    |   0.0 |  1.27
Other   |            | 0.04757    |            |       |  0.40

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   -16069.446   -16069.446   -16134.054   -16134.054    250.04203    250.04203    36351.092    36351.092    901.21897    901.21897 
    2000   -16067.804   -16067.804   -16131.269   -16131.269    245.61776    245.61776    36434.985    36434.985   -2795.2173   -2795.2173 
Loop time of 10.5469 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.192 ns/day, 2.930 hours/ns, 94.814 timesteps/s
95.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    | 10.353     | 10.353     | 10.353     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.033101   | 0.033101   | 0.033101   |   0.0 |  0.31
Output  | 0.00010986 | 0.00010986 | 0.00010986 |   0.0 |  0.00
Modify  | 0.14048    | 0.14048    | 0.14048    |   0.0 |  1.33
Other   |            | 0.0202     |            |       |  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:      223506.0 ave      223506 max      223506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223506
Ave neighs/atom = 111.75300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -16067.804   -16067.804   -16131.269   -16131.269    245.61776    245.61776    36434.985    36434.985   -2795.2173   -2795.2173 
    3000   -16071.817   -16071.817   -16137.486   -16137.486    254.14533    254.14533    36334.122    36334.122    987.43686    987.43686 
Loop time of 10.015 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.627 ns/day, 2.782 hours/ns, 99.850 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.8249     | 9.8249     | 9.8249     |   0.0 | 98.10
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032578   | 0.032578   | 0.032578   |   0.0 |  0.33
Output  | 0.00011244 | 0.00011244 | 0.00011244 |   0.0 |  0.00
Modify  | 0.13831    | 0.13831    | 0.13831    |   0.0 |  1.38
Other   |            | 0.01903    |            |       |  0.19

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

Total # of neighbors = 223354
Ave neighs/atom = 111.67700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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   -16071.817   -16071.817   -16137.486   -16137.486    254.14533    254.14533    36334.122    36334.122    987.43686    987.43686 
    4000   -16066.233   -16066.233    -16134.62    -16134.62    264.66485    264.66485    36344.292    36344.292    1126.6174    1126.6174 
Loop time of 10.0002 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.640 ns/day, 2.778 hours/ns, 99.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.8107     | 9.8107     | 9.8107     |   0.0 | 98.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032734   | 0.032734   | 0.032734   |   0.0 |  0.33
Output  | 9.5859e-05 | 9.5859e-05 | 9.5859e-05 |   0.0 |  0.00
Modify  | 0.13771    | 0.13771    | 0.13771    |   0.0 |  1.38
Other   |            | 0.01892    |            |       |  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:      223606.0 ave      223606 max      223606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223606
Ave neighs/atom = 111.80300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -16066.233   -16066.233    -16134.62    -16134.62    264.66485    264.66485    36344.292    36344.292    1126.6174    1126.6174 
    5000   -16071.217   -16071.217   -16135.294   -16135.294    247.98487    247.98487    36358.743    36358.743    170.72732    170.72732 
Loop time of 9.99122 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.648 ns/day, 2.775 hours/ns, 100.088 timesteps/s
100.0% 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.8016     | 9.8016     | 9.8016     |   0.0 | 98.10
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032607   | 0.032607   | 0.032607   |   0.0 |  0.33
Output  | 7.1233e-05 | 7.1233e-05 | 7.1233e-05 |   0.0 |  0.00
Modify  | 0.13804    | 0.13804    | 0.13804    |   0.0 |  1.38
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:      223554.0 ave      223554 max      223554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223554
Ave neighs/atom = 111.77700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 248.129883943133, Press = -10.9675026790762
next a
jump SELF top
variable a loop 2000
run 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   -16071.217   -16071.217   -16135.294   -16135.294    247.98487    247.98487    36358.743    36358.743    170.72732    170.72732 
    6000   -16068.521   -16068.521   -16133.858   -16133.858      252.861      252.861    36346.233    36346.233    1485.7682    1485.7682 
Loop time of 10.0062 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.635 ns/day, 2.779 hours/ns, 99.938 timesteps/s
100.0% 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.8127     | 9.8127     | 9.8127     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032744   | 0.032744   | 0.032744   |   0.0 |  0.33
Output  | 7.3194e-05 | 7.3194e-05 | 7.3194e-05 |   0.0 |  0.00
Modify  | 0.14177    | 0.14177    | 0.14177    |   0.0 |  1.42
Other   |            | 0.01892    |            |       |  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:      223522.0 ave      223522 max      223522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223522
Ave neighs/atom = 111.76100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.054033328933, Press = -61.6775694660197
next a
jump SELF top
variable a loop 2000
run 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   -16068.521   -16068.521   -16133.858   -16133.858      252.861      252.861    36346.233    36346.233    1485.7682    1485.7682 
    7000   -16067.261   -16067.261   -16134.977   -16134.977    262.06472    262.06472    36345.971    36345.971    1316.8675    1316.8675 
Loop time of 10.0209 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.622 ns/day, 2.784 hours/ns, 99.791 timesteps/s
100.0% 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.8274     | 9.8274     | 9.8274     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032758   | 0.032758   | 0.032758   |   0.0 |  0.33
Output  | 4.7278e-05 | 4.7278e-05 | 4.7278e-05 |   0.0 |  0.00
Modify  | 0.14176    | 0.14176    | 0.14176    |   0.0 |  1.41
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:      223506.0 ave      223506 max      223506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223506
Ave neighs/atom = 111.75300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.749104605611, Press = -2.46327224284107
next a
jump SELF top
variable a loop 2000
run 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   -16067.261   -16067.261   -16134.977   -16134.977    262.06472    262.06472    36345.971    36345.971    1316.8675    1316.8675 
    8000   -16072.167   -16072.167   -16137.137   -16137.137    251.44259    251.44259    36372.448    36372.448   -821.85464   -821.85464 
Loop time of 9.99981 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.640 ns/day, 2.778 hours/ns, 100.002 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.8065     | 9.8065     | 9.8065     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032832   | 0.032832   | 0.032832   |   0.0 |  0.33
Output  | 5.2191e-05 | 5.2191e-05 | 5.2191e-05 |   0.0 |  0.00
Modify  | 0.14153    | 0.14153    | 0.14153    |   0.0 |  1.42
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:      223584.0 ave      223584 max      223584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223584
Ave neighs/atom = 111.79200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.192630696354, Press = 2.92685473844875
next a
jump SELF top
variable a loop 2000
run 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   -16072.167   -16072.167   -16137.137   -16137.137    251.44259    251.44259    36372.448    36372.448   -821.85464   -821.85464 
    9000   -16067.984   -16067.984   -16134.661   -16134.661    258.04739    258.04739     36330.26     36330.26    2016.4901    2016.4901 
Loop time of 10.0034 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.637 ns/day, 2.779 hours/ns, 99.966 timesteps/s
100.0% 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.8099     | 9.8099     | 9.8099     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032743   | 0.032743   | 0.032743   |   0.0 |  0.33
Output  | 6.7596e-05 | 6.7596e-05 | 6.7596e-05 |   0.0 |  0.00
Modify  | 0.14178    | 0.14178    | 0.14178    |   0.0 |  1.42
Other   |            | 0.01892    |            |       |  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:      223530.0 ave      223530 max      223530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223530
Ave neighs/atom = 111.76500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.822373553543, Press = -1.15450779119301
next a
jump SELF top
variable a loop 2000
run 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   -16067.984   -16067.984   -16134.661   -16134.661    258.04739    258.04739     36330.26     36330.26    2016.4901    2016.4901 
   10000   -16070.055   -16070.055    -16134.49    -16134.49    249.36725    249.36725    36365.221    36365.221    149.80808    149.80808 
Loop time of 10.003 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.637 ns/day, 2.779 hours/ns, 99.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.8096     | 9.8096     | 9.8096     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032849   | 0.032849   | 0.032849   |   0.0 |  0.33
Output  | 4.91e-05   | 4.91e-05   | 4.91e-05   |   0.0 |  0.00
Modify  | 0.14161    | 0.14161    | 0.14161    |   0.0 |  1.42
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:      223594.0 ave      223594 max      223594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223594
Ave neighs/atom = 111.79700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.837831888924, Press = -6.77114282935477
next a
jump SELF top
variable a loop 2000
run 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   -16070.055   -16070.055    -16134.49    -16134.49    249.36725    249.36725    36365.221    36365.221    149.80808    149.80808 
   11000   -16069.454   -16069.454    -16134.27    -16134.27    250.84297    250.84297    36369.782    36369.782   -325.72393   -325.72393 
Loop time of 10.011 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.631 ns/day, 2.781 hours/ns, 99.890 timesteps/s
100.0% 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.8172     | 9.8172     | 9.8172     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032902   | 0.032902   | 0.032902   |   0.0 |  0.33
Output  | 5.7045e-05 | 5.7045e-05 | 5.7045e-05 |   0.0 |  0.00
Modify  | 0.14191    | 0.14191    | 0.14191    |   0.0 |  1.42
Other   |            | 0.01895    |            |       |  0.19

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

Total # of neighbors = 223476
Ave neighs/atom = 111.73800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.764368010975, Press = -12.2693953035613
next a
jump SELF top
variable a loop 2000
run 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   -16069.454   -16069.454    -16134.27    -16134.27    250.84297    250.84297    36369.782    36369.782   -325.72393   -325.72393 
   12000   -16070.717   -16070.717   -16134.902   -16134.902    248.40563    248.40563    36344.416    36344.416    1018.4554    1018.4554 
Loop time of 10.0229 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.620 ns/day, 2.784 hours/ns, 99.772 timesteps/s
100.0% 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.8291     | 9.8291     | 9.8291     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03283    | 0.03283    | 0.03283    |   0.0 |  0.33
Output  | 4.5146e-05 | 4.5146e-05 | 4.5146e-05 |   0.0 |  0.00
Modify  | 0.14192    | 0.14192    | 0.14192    |   0.0 |  1.42
Other   |            | 0.01895    |            |       |  0.19

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

Total # of neighbors = 223462
Ave neighs/atom = 111.73100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.456608203322, Press = -1.89732250540781
next a
jump SELF top
variable a loop 2000
run 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   -16070.717   -16070.717   -16134.902   -16134.902    248.40563    248.40563    36344.416    36344.416    1018.4554    1018.4554 
   13000   -16071.175   -16071.175   -16134.126   -16134.126     243.6268     243.6268    36385.375    36385.375   -783.44425   -783.44425 
Loop time of 10.0053 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.635 ns/day, 2.779 hours/ns, 99.947 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.8117     | 9.8117     | 9.8117     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032856   | 0.032856   | 0.032856   |   0.0 |  0.33
Output  | 6.85e-05   | 6.85e-05   | 6.85e-05   |   0.0 |  0.00
Modify  | 0.14175    | 0.14175    | 0.14175    |   0.0 |  1.42
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:      223504.0 ave      223504 max      223504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223504
Ave neighs/atom = 111.75200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.510020653705, Press = -5.35906485388947
next a
jump SELF top
variable a loop 2000
run 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   -16071.175   -16071.175   -16134.126   -16134.126     243.6268     243.6268    36385.375    36385.375   -783.44425   -783.44425 
   14000   -16067.288   -16067.288   -16132.782   -16132.782    253.46862    253.46862    36364.139    36364.139    622.36435    622.36435 
Loop time of 10.0183 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.624 ns/day, 2.783 hours/ns, 99.817 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.8252     | 9.8252     | 9.8252     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032685   | 0.032685   | 0.032685   |   0.0 |  0.33
Output  | 4.967e-05  | 4.967e-05  | 4.967e-05  |   0.0 |  0.00
Modify  | 0.14162    | 0.14162    | 0.14162    |   0.0 |  1.41
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:      223472.0 ave      223472 max      223472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223472
Ave neighs/atom = 111.73600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.721326354021, Press = 2.84939828821476
next a
jump SELF top
variable a loop 2000
run 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   -16067.288   -16067.288   -16132.782   -16132.782    253.46862    253.46862    36364.139    36364.139    622.36435    622.36435 
   15000   -16068.043   -16068.043   -16133.811   -16133.811    254.52837    254.52837    36400.373    36400.373   -1545.4127   -1545.4127 
Loop time of 10.0183 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.624 ns/day, 2.783 hours/ns, 99.817 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.8248     | 9.8248     | 9.8248     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032644   | 0.032644   | 0.032644   |   0.0 |  0.33
Output  | 0.00031248 | 0.00031248 | 0.00031248 |   0.0 |  0.00
Modify  | 0.14173    | 0.14173    | 0.14173    |   0.0 |  1.41
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:      223484.0 ave      223484 max      223484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223484
Ave neighs/atom = 111.74200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.621922604623, Press = -5.32869677111402
next a
jump SELF top
variable a loop 2000
run 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   -16068.043   -16068.043   -16133.811   -16133.811    254.52837    254.52837    36400.373    36400.373   -1545.4127   -1545.4127 
   16000   -16072.759   -16072.759   -16135.267   -16135.267    241.91014    241.91014    36351.509    36351.509    642.53637    642.53637 
Loop time of 10.0171 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.625 ns/day, 2.783 hours/ns, 99.829 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.8232     | 9.8232     | 9.8232     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032817   | 0.032817   | 0.032817   |   0.0 |  0.33
Output  | 5.9135e-05 | 5.9135e-05 | 5.9135e-05 |   0.0 |  0.00
Modify  | 0.14215    | 0.14215    | 0.14215    |   0.0 |  1.42
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:      223482.0 ave      223482 max      223482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223482
Ave neighs/atom = 111.74100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.509156747818, Press = -1.24519406600326
next a
jump SELF top
variable a loop 2000
run 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   -16072.759   -16072.759   -16135.267   -16135.267    241.91014    241.91014    36351.509    36351.509    642.53637    642.53637 
   17000   -16068.726   -16068.726   -16133.564   -16133.564    250.92816    250.92816    36371.807    36371.807    130.08657    130.08657 
Loop time of 10.0117 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.630 ns/day, 2.781 hours/ns, 99.883 timesteps/s
100.0% 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.818      | 9.818      | 9.818      |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032671   | 0.032671   | 0.032671   |   0.0 |  0.33
Output  | 6.0346e-05 | 6.0346e-05 | 6.0346e-05 |   0.0 |  0.00
Modify  | 0.14199    | 0.14199    | 0.14199    |   0.0 |  1.42
Other   |            | 0.01901    |            |       |  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:      223470.0 ave      223470 max      223470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223470
Ave neighs/atom = 111.73500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.458356042046, Press = -3.39154644991359
next a
jump SELF top
variable a loop 2000
run 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   -16068.726   -16068.726   -16133.564   -16133.564    250.92816    250.92816    36371.807    36371.807    130.08657    130.08657 
   18000   -16070.193   -16070.193   -16135.538   -16135.538    252.89164    252.89164    36314.977    36314.977    2702.7347    2702.7347 
Loop time of 10.0132 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.629 ns/day, 2.781 hours/ns, 99.868 timesteps/s
100.0% 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.8194     | 9.8194     | 9.8194     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032827   | 0.032827   | 0.032827   |   0.0 |  0.33
Output  | 5.9624e-05 | 5.9624e-05 | 5.9624e-05 |   0.0 |  0.00
Modify  | 0.142      | 0.142      | 0.142      |   0.0 |  1.42
Other   |            | 0.01895    |            |       |  0.19

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

Total # of neighbors = 223444
Ave neighs/atom = 111.72200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.479901270182, Press = -2.01202262887821
next a
jump SELF top
variable a loop 2000
run 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   -16070.193   -16070.193   -16135.538   -16135.538    252.89164    252.89164    36314.977    36314.977    2702.7347    2702.7347 
   19000   -16071.763   -16071.763   -16135.811   -16135.811    247.87355    247.87355    36354.727    36354.727    381.10812    381.10812 
Loop time of 10.0157 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.626 ns/day, 2.782 hours/ns, 99.843 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.8215     | 9.8215     | 9.8215     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032962   | 0.032962   | 0.032962   |   0.0 |  0.33
Output  | 8.4322e-05 | 8.4322e-05 | 8.4322e-05 |   0.0 |  0.00
Modify  | 0.14224    | 0.14224    | 0.14224    |   0.0 |  1.42
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:      223610.0 ave      223610 max      223610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223610
Ave neighs/atom = 111.80500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.505714580296, Press = -3.95164893659185
next a
jump SELF top
variable a loop 2000
run 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   -16071.763   -16071.763   -16135.811   -16135.811    247.87355    247.87355    36354.727    36354.727    381.10812    381.10812 
   20000   -16067.733   -16067.733   -16135.971   -16135.971    264.08871    264.08871    36345.517    36345.517     1106.148     1106.148 
Loop time of 10.0053 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.635 ns/day, 2.779 hours/ns, 99.947 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.8106     | 9.8106     | 9.8106     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.033031   | 0.033031   | 0.033031   |   0.0 |  0.33
Output  | 6.1743e-05 | 6.1743e-05 | 6.1743e-05 |   0.0 |  0.00
Modify  | 0.14263    | 0.14263    | 0.14263    |   0.0 |  1.43
Other   |            | 0.01894    |            |       |  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:      223514.0 ave      223514 max      223514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223514
Ave neighs/atom = 111.75700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.514147785993, Press = -3.55141967157983
next a
jump SELF top
variable a loop 2000
run 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   -16067.733   -16067.733   -16135.971   -16135.971    264.08871    264.08871    36345.517    36345.517     1106.148     1106.148 
   21000    -16070.88    -16070.88   -16135.975   -16135.975    251.92444    251.92444    36370.261    36370.261   -449.23243   -449.23243 
Loop time of 10.0256 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.618 ns/day, 2.785 hours/ns, 99.744 timesteps/s
100.0% 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.8316     | 9.8316     | 9.8316     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032938   | 0.032938   | 0.032938   |   0.0 |  0.33
Output  | 6.1615e-05 | 6.1615e-05 | 6.1615e-05 |   0.0 |  0.00
Modify  | 0.14207    | 0.14207    | 0.14207    |   0.0 |  1.42
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:      223606.0 ave      223606 max      223606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223606
Ave neighs/atom = 111.80300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.460013805635, Press = -3.1817956466303
next a
jump SELF top
variable a loop 2000
run 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    -16070.88    -16070.88   -16135.975   -16135.975    251.92444    251.92444    36370.261    36370.261   -449.23243   -449.23243 
   22000   -16069.471   -16069.471   -16133.969   -16133.969    249.61112    249.61112     36382.87     36382.87   -628.04481   -628.04481 
Loop time of 10.025 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.618 ns/day, 2.785 hours/ns, 99.751 timesteps/s
100.0% 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.8311     | 9.8311     | 9.8311     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032994   | 0.032994   | 0.032994   |   0.0 |  0.33
Output  | 6.0538e-05 | 6.0538e-05 | 6.0538e-05 |   0.0 |  0.00
Modify  | 0.14194    | 0.14194    | 0.14194    |   0.0 |  1.42
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:      223540.0 ave      223540 max      223540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223540
Ave neighs/atom = 111.77000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.466257198962, Press = -2.39482293155392
next a
jump SELF top
variable a loop 2000
run 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   -16069.471   -16069.471   -16133.969   -16133.969    249.61112    249.61112     36382.87     36382.87   -628.04481   -628.04481 
   23000   -16069.968   -16069.968   -16136.639   -16136.639    258.02447    258.02447    36361.407    36361.407   -192.54357   -192.54357 
Loop time of 10.0339 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.611 ns/day, 2.787 hours/ns, 99.663 timesteps/s
100.0% 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.84       | 9.84       | 9.84       |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032698   | 0.032698   | 0.032698   |   0.0 |  0.33
Output  | 5.9485e-05 | 5.9485e-05 | 5.9485e-05 |   0.0 |  0.00
Modify  | 0.14213    | 0.14213    | 0.14213    |   0.0 |  1.42
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:      223502.0 ave      223502 max      223502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223502
Ave neighs/atom = 111.75100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.403058998616, Press = -2.51081200125825
next a
jump SELF top
variable a loop 2000
run 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   -16069.968   -16069.968   -16136.639   -16136.639    258.02447    258.02447    36361.407    36361.407   -192.54357   -192.54357 
   24000   -16069.632   -16069.632   -16133.642   -16133.642    247.72545    247.72545    36399.907    36399.907   -1533.0241   -1533.0241 
Loop time of 10.0425 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.603 ns/day, 2.790 hours/ns, 99.576 timesteps/s
100.0% 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.8486     | 9.8486     | 9.8486     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032888   | 0.032888   | 0.032888   |   0.0 |  0.33
Output  | 6.1198e-05 | 6.1198e-05 | 6.1198e-05 |   0.0 |  0.00
Modify  | 0.1421     | 0.1421     | 0.1421     |   0.0 |  1.41
Other   |            | 0.01892    |            |       |  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:      223620.0 ave      223620 max      223620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223620
Ave neighs/atom = 111.81000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.455979222931, Press = -2.28323308988791
next a
jump SELF top
variable a loop 2000
run 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   -16069.632   -16069.632   -16133.642   -16133.642    247.72545    247.72545    36399.907    36399.907   -1533.0241   -1533.0241 
   25000   -16068.583   -16068.583   -16134.304   -16134.304    254.34503    254.34503    36387.551    36387.551   -984.75818   -984.75818 
Loop time of 10.0356 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.609 ns/day, 2.788 hours/ns, 99.645 timesteps/s
100.0% 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.8416     | 9.8416     | 9.8416     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032788   | 0.032788   | 0.032788   |   0.0 |  0.33
Output  | 8.4987e-05 | 8.4987e-05 | 8.4987e-05 |   0.0 |  0.00
Modify  | 0.14222    | 0.14222    | 0.14222    |   0.0 |  1.42
Other   |            | 0.01895    |            |       |  0.19

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

Total # of neighbors = 223522
Ave neighs/atom = 111.76100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.483307579366, Press = -1.95447442298573
next a
jump SELF top
variable a loop 2000
run 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   -16068.583   -16068.583   -16134.304   -16134.304    254.34503    254.34503    36387.551    36387.551   -984.75818   -984.75818 
   26000   -16071.632   -16071.632   -16137.874   -16137.874    256.36445    256.36445    36357.843    36357.843   -328.15749   -328.15749 
Loop time of 10.0306 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.614 ns/day, 2.786 hours/ns, 99.695 timesteps/s
100.0% 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.8366     | 9.8366     | 9.8366     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032822   | 0.032822   | 0.032822   |   0.0 |  0.33
Output  | 5.9149e-05 | 5.9149e-05 | 5.9149e-05 |   0.0 |  0.00
Modify  | 0.14214    | 0.14214    | 0.14214    |   0.0 |  1.42
Other   |            | 0.01898    |            |       |  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:      223508.0 ave      223508 max      223508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223508
Ave neighs/atom = 111.75400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.500982652984, Press = -2.52843692649979
next a
jump SELF top
variable a loop 2000
run 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   -16071.632   -16071.632   -16137.874   -16137.874    256.36445    256.36445    36357.843    36357.843   -328.15749   -328.15749 
   27000   -16067.086   -16067.086   -16133.682   -16133.682    257.73401    257.73401    36425.254    36425.254   -2719.5326   -2719.5326 
Loop time of 10.0265 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.617 ns/day, 2.785 hours/ns, 99.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.8327     | 9.8327     | 9.8327     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03278    | 0.03278    | 0.03278    |   0.0 |  0.33
Output  | 6.1253e-05 | 6.1253e-05 | 6.1253e-05 |   0.0 |  0.00
Modify  | 0.14191    | 0.14191    | 0.14191    |   0.0 |  1.42
Other   |            | 0.01899    |            |       |  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:      223626.0 ave      223626 max      223626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223626
Ave neighs/atom = 111.81300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.528443174928, Press = -1.66197865248578
next a
jump SELF top
variable a loop 2000
run 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   -16067.086   -16067.086   -16133.682   -16133.682    257.73401    257.73401    36425.254    36425.254   -2719.5326   -2719.5326 
   28000   -16067.936   -16067.936   -16133.892   -16133.892    255.25352    255.25352    36376.839    36376.839   -265.78064   -265.78064 
Loop time of 10.0344 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.610 ns/day, 2.787 hours/ns, 99.658 timesteps/s
100.0% 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.8406     | 9.8406     | 9.8406     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032827   | 0.032827   | 0.032827   |   0.0 |  0.33
Output  | 6.1125e-05 | 6.1125e-05 | 6.1125e-05 |   0.0 |  0.00
Modify  | 0.14187    | 0.14187    | 0.14187    |   0.0 |  1.41
Other   |            | 0.019      |            |       |  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:      223470.0 ave      223470 max      223470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223470
Ave neighs/atom = 111.73500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.498085381218, Press = -0.658725463051697
next a
jump SELF top
variable a loop 2000
run 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   -16067.936   -16067.936   -16133.892   -16133.892    255.25352    255.25352    36376.839    36376.839   -265.78064   -265.78064 
   29000   -16072.135   -16072.135   -16136.316   -16136.316    248.38606    248.38606    36407.345    36407.345   -2653.9932   -2653.9932 
Loop time of 10.0206 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.622 ns/day, 2.783 hours/ns, 99.795 timesteps/s
100.0% 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.8264     | 9.8264     | 9.8264     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032926   | 0.032926   | 0.032926   |   0.0 |  0.33
Output  | 6.0343e-05 | 6.0343e-05 | 6.0343e-05 |   0.0 |  0.00
Modify  | 0.14222    | 0.14222    | 0.14222    |   0.0 |  1.42
Other   |            | 0.01901    |            |       |  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:      223488.0 ave      223488 max      223488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223488
Ave neighs/atom = 111.74400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.498138837646, Press = -1.4482389435193
next a
jump SELF top
variable a loop 2000
run 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   -16072.135   -16072.135   -16136.316   -16136.316    248.38606    248.38606    36407.345    36407.345   -2653.9932   -2653.9932 
   30000    -16068.47    -16068.47   -16132.894   -16132.894     249.3286     249.3286    36422.063    36422.063   -2466.1673   -2466.1673 
Loop time of 10.032 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.612 ns/day, 2.787 hours/ns, 99.681 timesteps/s
100.0% 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.8381     | 9.8381     | 9.8381     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032905   | 0.032905   | 0.032905   |   0.0 |  0.33
Output  | 5.9718e-05 | 5.9718e-05 | 5.9718e-05 |   0.0 |  0.00
Modify  | 0.14193    | 0.14193    | 0.14193    |   0.0 |  1.41
Other   |            | 0.01896    |            |       |  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:      223528.0 ave      223528 max      223528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223528
Ave neighs/atom = 111.76400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.482161898017, Press = -1.53698738389433
next a
jump SELF top
variable a loop 2000
run 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    -16068.47    -16068.47   -16132.894   -16132.894     249.3286     249.3286    36422.063    36422.063   -2466.1673   -2466.1673 
   31000   -16069.698   -16069.698   -16135.271   -16135.271    253.77624    253.77624    36367.044    36367.044     27.69334     27.69334 
Loop time of 10.0286 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.615 ns/day, 2.786 hours/ns, 99.715 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.834      | 9.834      | 9.834      |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032943   | 0.032943   | 0.032943   |   0.0 |  0.33
Output  | 8.3892e-05 | 8.3892e-05 | 8.3892e-05 |   0.0 |  0.00
Modify  | 0.14252    | 0.14252    | 0.14252    |   0.0 |  1.42
Other   |            | 0.01908    |            |       |  0.19

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

Total # of neighbors = 223390
Ave neighs/atom = 111.69500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.429573263928, Press = -1.48937665910881
next a
jump SELF top
variable a loop 2000
run 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   -16069.698   -16069.698   -16135.271   -16135.271    253.77624    253.77624    36367.044    36367.044     27.69334     27.69334 
   32000   -16070.761   -16070.761   -16134.979   -16134.979    248.53186    248.53186     36338.24     36338.24    1575.0422    1575.0422 
Loop time of 10.0227 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.620 ns/day, 2.784 hours/ns, 99.774 timesteps/s
100.0% 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.8291     | 9.8291     | 9.8291     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032771   | 0.032771   | 0.032771   |   0.0 |  0.33
Output  | 6.1236e-05 | 6.1236e-05 | 6.1236e-05 |   0.0 |  0.00
Modify  | 0.14178    | 0.14178    | 0.14178    |   0.0 |  1.41
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:      223648.0 ave      223648 max      223648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223648
Ave neighs/atom = 111.82400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.482728793932, Press = 0.851199236689098
next a
jump SELF top
variable a loop 2000
run 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   -16070.761   -16070.761   -16134.979   -16134.979    248.53186    248.53186     36338.24     36338.24    1575.0422    1575.0422 
   33000    -16067.59    -16067.59   -16135.278   -16135.278    261.95992    261.95992    36337.744    36337.744    1435.5121    1435.5121 
Loop time of 10.0294 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.615 ns/day, 2.786 hours/ns, 99.707 timesteps/s
100.0% 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.8356     | 9.8356     | 9.8356     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032656   | 0.032656   | 0.032656   |   0.0 |  0.33
Output  | 6.0115e-05 | 6.0115e-05 | 6.0115e-05 |   0.0 |  0.00
Modify  | 0.14209    | 0.14209    | 0.14209    |   0.0 |  1.42
Other   |            | 0.01892    |            |       |  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:      223590.0 ave      223590 max      223590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223590
Ave neighs/atom = 111.79500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.431494188243, Press = -1.07443915044996
next a
jump SELF top
variable a loop 2000
run 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    -16067.59    -16067.59   -16135.278   -16135.278    261.95992    261.95992    36337.744    36337.744    1435.5121    1435.5121 
   34000   -16069.809   -16069.809   -16134.688   -16134.688    251.08818    251.08818    36388.478    36388.478   -1104.7209   -1104.7209 
Loop time of 10.0246 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.619 ns/day, 2.785 hours/ns, 99.755 timesteps/s
100.0% 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.8308     | 9.8308     | 9.8308     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032948   | 0.032948   | 0.032948   |   0.0 |  0.33
Output  | 5.988e-05  | 5.988e-05  | 5.988e-05  |   0.0 |  0.00
Modify  | 0.14179    | 0.14179    | 0.14179    |   0.0 |  1.41
Other   |            | 0.01902    |            |       |  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:      223602.0 ave      223602 max      223602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223602
Ave neighs/atom = 111.80100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.4763591609, Press = -1.12389745101728
next a
jump SELF top
variable a loop 2000
run 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   -16069.809   -16069.809   -16134.688   -16134.688    251.08818    251.08818    36388.478    36388.478   -1104.7209   -1104.7209 
   35000    -16067.15    -16067.15   -16133.842   -16133.842    258.10701    258.10701     36369.49     36369.49    249.72432    249.72432 
Loop time of 10.0237 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.620 ns/day, 2.784 hours/ns, 99.764 timesteps/s
100.0% 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.8301     | 9.8301     | 9.8301     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032801   | 0.032801   | 0.032801   |   0.0 |  0.33
Output  | 6.2066e-05 | 6.2066e-05 | 6.2066e-05 |   0.0 |  0.00
Modify  | 0.14176    | 0.14176    | 0.14176    |   0.0 |  1.41
Other   |            | 0.01896    |            |       |  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:      223492.0 ave      223492 max      223492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223492
Ave neighs/atom = 111.74600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.568876613547, Press = -1.57116870958299
next a
jump SELF top
variable a loop 2000
run 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    -16067.15    -16067.15   -16133.842   -16133.842    258.10701    258.10701     36369.49     36369.49    249.72432    249.72432 
   36000   -16067.743   -16067.743   -16132.702   -16132.702    251.40033    251.40033     36391.89     36391.89   -830.33015   -830.33015 
Loop time of 10.0275 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.616 ns/day, 2.785 hours/ns, 99.726 timesteps/s
100.0% 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.8335     | 9.8335     | 9.8335     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032953   | 0.032953   | 0.032953   |   0.0 |  0.33
Output  | 6.0719e-05 | 6.0719e-05 | 6.0719e-05 |   0.0 |  0.00
Modify  | 0.14207    | 0.14207    | 0.14207    |   0.0 |  1.42
Other   |            | 0.01896    |            |       |  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:      223512.0 ave      223512 max      223512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223512
Ave neighs/atom = 111.75600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.565317653523, Press = -0.973191168923703
next a
jump SELF top
variable a loop 2000
run 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   -16067.743   -16067.743   -16132.702   -16132.702    251.40033    251.40033     36391.89     36391.89   -830.33015   -830.33015 
   37000   -16068.293   -16068.293   -16134.306   -16134.306    255.47694    255.47694    36356.194    36356.194    686.29262    686.29262 
Loop time of 10.0432 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.603 ns/day, 2.790 hours/ns, 99.570 timesteps/s
100.0% 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.8491     | 9.8491     | 9.8491     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032763   | 0.032763   | 0.032763   |   0.0 |  0.33
Output  | 8.7291e-05 | 8.7291e-05 | 8.7291e-05 |   0.0 |  0.00
Modify  | 0.14218    | 0.14218    | 0.14218    |   0.0 |  1.42
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:      223454.0 ave      223454 max      223454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223454
Ave neighs/atom = 111.72700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.524469260647, Press = 0.389463658215513
next a
jump SELF top
variable a loop 2000
run 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   -16068.293   -16068.293   -16134.306   -16134.306    255.47694    255.47694    36356.194    36356.194    686.29262    686.29262 
   38000   -16072.318   -16072.318   -16137.074   -16137.074      250.615      250.615    36353.148    36353.148    53.797792    53.797792 
Loop time of 10.0112 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.630 ns/day, 2.781 hours/ns, 99.888 timesteps/s
100.0% 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.8172     | 9.8172     | 9.8172     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032728   | 0.032728   | 0.032728   |   0.0 |  0.33
Output  | 6.4455e-05 | 6.4455e-05 | 6.4455e-05 |   0.0 |  0.00
Modify  | 0.14226    | 0.14226    | 0.14226    |   0.0 |  1.42
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:      223502.0 ave      223502 max      223502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223502
Ave neighs/atom = 111.75100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.476405167467, Press = -0.895669301447858
next a
jump SELF top
variable a loop 2000
run 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   -16072.318   -16072.318   -16137.074   -16137.074      250.615      250.615    36353.148    36353.148    53.797792    53.797792 
   39000    -16068.85    -16068.85   -16134.792   -16134.792    255.20047    255.20047     36430.76     36430.76   -3520.0621   -3520.0621 
Loop time of 10.0095 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.632 ns/day, 2.780 hours/ns, 99.905 timesteps/s
100.0% 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.8157     | 9.8157     | 9.8157     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03274    | 0.03274    | 0.03274    |   0.0 |  0.33
Output  | 6.5652e-05 | 6.5652e-05 | 6.5652e-05 |   0.0 |  0.00
Modify  | 0.14218    | 0.14218    | 0.14218    |   0.0 |  1.42
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:      223522.0 ave      223522 max      223522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223522
Ave neighs/atom = 111.76100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.456612077596, Press = 0.680049590002572
next a
jump SELF top
variable a loop 2000
run 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    -16068.85    -16068.85   -16134.792   -16134.792    255.20047    255.20047     36430.76     36430.76   -3520.0621   -3520.0621 
   40000   -16070.101   -16070.101   -16135.814   -16135.814    254.31611    254.31611    36321.378    36321.378    2156.7333    2156.7333 
Loop time of 10.01 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.631 ns/day, 2.781 hours/ns, 99.900 timesteps/s
100.0% 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.8163     | 9.8163     | 9.8163     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032816   | 0.032816   | 0.032816   |   0.0 |  0.33
Output  | 6.2607e-05 | 6.2607e-05 | 6.2607e-05 |   0.0 |  0.00
Modify  | 0.14183    | 0.14183    | 0.14183    |   0.0 |  1.42
Other   |            | 0.01894    |            |       |  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:      223426.0 ave      223426 max      223426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223426
Ave neighs/atom = 111.71300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.501246589114, Press = -0.651169687489126
next a
jump SELF top
variable a loop 2000
run 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   -16070.101   -16070.101   -16135.814   -16135.814    254.31611    254.31611    36321.378    36321.378    2156.7333    2156.7333 
   41000   -16067.369   -16067.369   -16132.332   -16132.332    251.41623    251.41623     36410.67     36410.67   -1514.0866   -1514.0866 
Loop time of 10.0037 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.637 ns/day, 2.779 hours/ns, 99.963 timesteps/s
100.0% 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.8099     | 9.8099     | 9.8099     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032855   | 0.032855   | 0.032855   |   0.0 |  0.33
Output  | 6.377e-05  | 6.377e-05  | 6.377e-05  |   0.0 |  0.00
Modify  | 0.14201    | 0.14201    | 0.14201    |   0.0 |  1.42
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:      223572.0 ave      223572 max      223572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223572
Ave neighs/atom = 111.78600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.566668973529, Press = -0.572208895755971
next a
jump SELF top
variable a loop 2000
run 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   -16067.369   -16067.369   -16132.332   -16132.332    251.41623    251.41623     36410.67     36410.67   -1514.0866   -1514.0866 
   42000   -16069.877   -16069.877    -16134.34    -16134.34    249.47734    249.47734    36365.662    36365.662    195.14354    195.14354 
Loop time of 10.0083 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.633 ns/day, 2.780 hours/ns, 99.918 timesteps/s
100.0% 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.8147     | 9.8147     | 9.8147     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032812   | 0.032812   | 0.032812   |   0.0 |  0.33
Output  | 6.2076e-05 | 6.2076e-05 | 6.2076e-05 |   0.0 |  0.00
Modify  | 0.14189    | 0.14189    | 0.14189    |   0.0 |  1.42
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:      223436.0 ave      223436 max      223436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223436
Ave neighs/atom = 111.71800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.565894018464, Press = -1.64805960468412
next a
jump SELF top
variable a loop 2000
run 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   -16069.877   -16069.877    -16134.34    -16134.34    249.47734    249.47734    36365.662    36365.662    195.14354    195.14354 
   43000   -16069.553   -16069.553   -16136.167   -16136.167    257.80495    257.80495    36321.058    36321.058     2216.974     2216.974 
Loop time of 10.0129 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.629 ns/day, 2.781 hours/ns, 99.872 timesteps/s
100.0% 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.8187     | 9.8187     | 9.8187     |   0.0 | 98.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03281    | 0.03281    | 0.03281    |   0.0 |  0.33
Output  | 0.00017418 | 0.00017418 | 0.00017418 |   0.0 |  0.00
Modify  | 0.14227    | 0.14227    | 0.14227    |   0.0 |  1.42
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:      223582.0 ave      223582 max      223582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223582
Ave neighs/atom = 111.79100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.600016563259, Press = -0.469056420614739
next a
jump SELF top
variable a loop 2000
run 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   -16069.553   -16069.553   -16136.167   -16136.167    257.80495    257.80495    36321.058    36321.058     2216.974     2216.974 
   44000   -16066.727   -16066.727    -16132.22    -16132.22    253.46763    253.46763    36396.711    36396.711   -1063.8906   -1063.8906 
Loop time of 10.0141 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.628 ns/day, 2.782 hours/ns, 99.859 timesteps/s
100.0% 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.8209     | 9.8209     | 9.8209     |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0325     | 0.0325     | 0.0325     |   0.0 |  0.32
Output  | 6.4172e-05 | 6.4172e-05 | 6.4172e-05 |   0.0 |  0.00
Modify  | 0.14175    | 0.14175    | 0.14175    |   0.0 |  1.42
Other   |            | 0.01892    |            |       |  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:      223622.0 ave      223622 max      223622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223622
Ave neighs/atom = 111.81100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.651271047879, Press = -1.09110854030111
next a
jump SELF top
variable a loop 2000
run 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   -16066.727   -16066.727    -16132.22    -16132.22    253.46763    253.46763    36396.711    36396.711   -1063.8906   -1063.8906 
   45000   -16070.584   -16070.584   -16136.556   -16136.556    255.32139    255.32139    36382.169    36382.169   -1352.7502   -1352.7502 
Loop time of 9.97703 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.660 ns/day, 2.771 hours/ns, 100.230 timesteps/s
100.0% 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.783      | 9.783      | 9.783      |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032737   | 0.032737   | 0.032737   |   0.0 |  0.33
Output  | 6.0932e-05 | 6.0932e-05 | 6.0932e-05 |   0.0 |  0.00
Modify  | 0.1421     | 0.1421     | 0.1421     |   0.0 |  1.42
Other   |            | 0.01917    |            |       |  0.19

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

Total # of neighbors = 223378
Ave neighs/atom = 111.68900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.691799265963, Press = -1.69337459623805
next a
jump SELF top
variable a loop 2000
run 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   -16070.584   -16070.584   -16136.556   -16136.556    255.32139    255.32139    36382.169    36382.169   -1352.7502   -1352.7502 
   46000   -16067.361   -16067.361   -16134.052   -16134.052    258.10247    258.10247     36397.63     36397.63   -1352.1603   -1352.1603 
Loop time of 9.87293 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.751 ns/day, 2.742 hours/ns, 101.287 timesteps/s
100.0% 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.684      | 9.684      | 9.684      |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032291   | 0.032291   | 0.032291   |   0.0 |  0.33
Output  | 6.0204e-05 | 6.0204e-05 | 6.0204e-05 |   0.0 |  0.00
Modify  | 0.1378     | 0.1378     | 0.1378     |   0.0 |  1.40
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:      223530.0 ave      223530 max      223530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223530
Ave neighs/atom = 111.76500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.715661669411, Press = -0.301094974450359
next a
jump SELF top
variable a loop 2000
run 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   -16067.361   -16067.361   -16134.052   -16134.052    258.10247    258.10247     36397.63     36397.63   -1352.1603   -1352.1603 
   47000   -16069.499   -16069.499    -16136.91    -16136.91    260.89046    260.89046    36364.742    36364.742   -459.34661   -459.34661 
Loop time of 9.84478 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.776 ns/day, 2.735 hours/ns, 101.577 timesteps/s
100.0% 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.6569     | 9.6569     | 9.6569     |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032231   | 0.032231   | 0.032231   |   0.0 |  0.33
Output  | 6.0242e-05 | 6.0242e-05 | 6.0242e-05 |   0.0 |  0.00
Modify  | 0.13696    | 0.13696    | 0.13696    |   0.0 |  1.39
Other   |            | 0.01868    |            |       |  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:      223542.0 ave      223542 max      223542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223542
Ave neighs/atom = 111.77100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.747880446378, Press = -0.798212534431801
next a
jump SELF top
variable a loop 2000
run 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   -16069.499   -16069.499    -16136.91    -16136.91    260.89046    260.89046    36364.742    36364.742   -459.34661   -459.34661 
   48000   -16068.292   -16068.292   -16135.192   -16135.192    258.91313    258.91313    36362.561    36362.561    35.081414    35.081414 
Loop time of 9.84995 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6618     | 9.6618     | 9.6618     |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03209    | 0.03209    | 0.03209    |   0.0 |  0.33
Output  | 5.9865e-05 | 5.9865e-05 | 5.9865e-05 |   0.0 |  0.00
Modify  | 0.13722    | 0.13722    | 0.13722    |   0.0 |  1.39
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:      223556.0 ave      223556 max      223556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223556
Ave neighs/atom = 111.77800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.768240850385, Press = -0.548976479785195
next a
jump SELF top
variable a loop 2000
run 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   -16068.292   -16068.292   -16135.192   -16135.192    258.91313    258.91313    36362.561    36362.561    35.081414    35.081414 
   49000   -16070.746   -16070.746   -16136.275   -16136.275    253.60458    253.60458    36285.212    36285.212    4024.8271    4024.8271 
Loop time of 9.87948 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.745 ns/day, 2.744 hours/ns, 101.220 timesteps/s
100.0% 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.6911     | 9.6911     | 9.6911     |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032241   | 0.032241   | 0.032241   |   0.0 |  0.33
Output  | 7.8152e-05 | 7.8152e-05 | 7.8152e-05 |   0.0 |  0.00
Modify  | 0.13723    | 0.13723    | 0.13723    |   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:      223490.0 ave      223490 max      223490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223490
Ave neighs/atom = 111.74500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.771460827887, Press = 0.363862202088439
next a
jump SELF top
variable a loop 2000
run 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   -16070.746   -16070.746   -16136.275   -16136.275    253.60458    253.60458    36285.212    36285.212    4024.8271    4024.8271 
   50000   -16068.452   -16068.452   -16134.104   -16134.104    254.08061    254.08061    36391.274    36391.274   -1237.3429   -1237.3429 
Loop time of 9.87151 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.752 ns/day, 2.742 hours/ns, 101.302 timesteps/s
100.0% 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.6837     | 9.6837     | 9.6837     |   0.0 | 98.10
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032013   | 0.032013   | 0.032013   |   0.0 |  0.32
Output  | 5.9325e-05 | 5.9325e-05 | 5.9325e-05 |   0.0 |  0.00
Modify  | 0.13718    | 0.13718    | 0.13718    |   0.0 |  1.39
Other   |            | 0.01854    |            |       |  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:      223642.0 ave      223642 max      223642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223642
Ave neighs/atom = 111.82100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.794035244351, Press = -1.36743216224155
next a
jump SELF top
variable a loop 2000
run 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   -16068.452   -16068.452   -16134.104   -16134.104    254.08061    254.08061    36391.274    36391.274   -1237.3429   -1237.3429 
   51000    -16070.13    -16070.13    -16135.55    -16135.55    253.18342    253.18342    36372.015    36372.015   -499.23009   -499.23009 
Loop time of 9.8635 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.760 ns/day, 2.740 hours/ns, 101.384 timesteps/s
100.0% 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.6755     | 9.6755     | 9.6755     |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032169   | 0.032169   | 0.032169   |   0.0 |  0.33
Output  | 5.9453e-05 | 5.9453e-05 | 5.9453e-05 |   0.0 |  0.00
Modify  | 0.13716    | 0.13716    | 0.13716    |   0.0 |  1.39
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:      223514.0 ave      223514 max      223514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223514
Ave neighs/atom = 111.75700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.807189003912, Press = -1.10941144591332
next a
jump SELF top
variable a loop 2000
run 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    -16070.13    -16070.13    -16135.55    -16135.55    253.18342    253.18342    36372.015    36372.015   -499.23009   -499.23009 
   52000   -16066.452   -16066.452   -16132.884   -16132.884    257.10041    257.10041    36389.731    36389.731   -658.83985   -658.83985 
Loop time of 9.87992 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6915     | 9.6915     | 9.6915     |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032208   | 0.032208   | 0.032208   |   0.0 |  0.33
Output  | 6.0017e-05 | 6.0017e-05 | 6.0017e-05 |   0.0 |  0.00
Modify  | 0.13739    | 0.13739    | 0.13739    |   0.0 |  1.39
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:      223506.0 ave      223506 max      223506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223506
Ave neighs/atom = 111.75300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.816595514558, Press = 0.0531559068484389
next a
jump SELF top
variable a loop 2000
run 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   -16066.452   -16066.452   -16132.884   -16132.884    257.10041    257.10041    36389.731    36389.731   -658.83985   -658.83985 
   53000    -16069.95    -16069.95   -16136.813   -16136.813    258.77039    258.77039    36386.732    36386.732   -1772.5288   -1772.5288 
Loop time of 9.87343 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.751 ns/day, 2.743 hours/ns, 101.282 timesteps/s
100.0% 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.6854     | 9.6854     | 9.6854     |   0.0 | 98.10
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032357   | 0.032357   | 0.032357   |   0.0 |  0.33
Output  | 5.8014e-05 | 5.8014e-05 | 5.8014e-05 |   0.0 |  0.00
Modify  | 0.1371     | 0.1371     | 0.1371     |   0.0 |  1.39
Other   |            | 0.01855    |            |       |  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:      223430.0 ave      223430 max      223430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223430
Ave neighs/atom = 111.71500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.8568141614, Press = -0.0343260775484808
next a
jump SELF top
variable a loop 2000
run 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    -16069.95    -16069.95   -16136.813   -16136.813    258.77039    258.77039    36386.732    36386.732   -1772.5288   -1772.5288 
   54000   -16069.216   -16069.216   -16134.898   -16134.898     254.1942     254.1942    36395.094    36395.094   -1848.0823   -1848.0823 
Loop time of 9.86308 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.760 ns/day, 2.740 hours/ns, 101.388 timesteps/s
100.0% 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.675      | 9.675      | 9.675      |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032066   | 0.032066   | 0.032066   |   0.0 |  0.33
Output  | 5.9507e-05 | 5.9507e-05 | 5.9507e-05 |   0.0 |  0.00
Modify  | 0.13729    | 0.13729    | 0.13729    |   0.0 |  1.39
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:      223550.0 ave      223550 max      223550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223550
Ave neighs/atom = 111.77500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.873580985631, Press = 0.335639152686645
next a
jump SELF top
variable a loop 2000
run 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   -16069.216   -16069.216   -16134.898   -16134.898     254.1942     254.1942    36395.094    36395.094   -1848.0823   -1848.0823 
   55000   -16066.579   -16066.579    -16134.02    -16134.02    261.00598    261.00598    36361.711    36361.711    333.25596    333.25596 
Loop time of 9.85024 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6622     | 9.6622     | 9.6622     |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032097   | 0.032097   | 0.032097   |   0.0 |  0.33
Output  | 5.9399e-05 | 5.9399e-05 | 5.9399e-05 |   0.0 |  0.00
Modify  | 0.13722    | 0.13722    | 0.13722    |   0.0 |  1.39
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:      223444.0 ave      223444 max      223444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223444
Ave neighs/atom = 111.72200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.886665019657, Press = -1.18781103801364
next a
jump SELF top
variable a loop 2000
run 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   -16066.579   -16066.579    -16134.02    -16134.02    261.00598    261.00598    36361.711    36361.711    333.25596    333.25596 
   56000   -16069.997   -16069.997   -16134.422   -16134.422    249.33324    249.33324    36368.515    36368.515   -131.81299   -131.81299 
Loop time of 9.86059 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.762 ns/day, 2.739 hours/ns, 101.414 timesteps/s
100.0% 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.6725     | 9.6725     | 9.6725     |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032195   | 0.032195   | 0.032195   |   0.0 |  0.33
Output  | 5.9602e-05 | 5.9602e-05 | 5.9602e-05 |   0.0 |  0.00
Modify  | 0.13709    | 0.13709    | 0.13709    |   0.0 |  1.39
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:      223524.0 ave      223524 max      223524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223524
Ave neighs/atom = 111.76200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.929315581164, Press = -0.704854422712944
next a
jump SELF top
variable a loop 2000
run 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   -16069.997   -16069.997   -16134.422   -16134.422    249.33324    249.33324    36368.515    36368.515   -131.81299   -131.81299 
   57000   -16068.889   -16068.889   -16134.438   -16134.438    253.68364    253.68364    36338.538    36338.538    1509.5812    1509.5812 
Loop time of 10.0662 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.583 ns/day, 2.796 hours/ns, 99.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.864      | 9.864      | 9.864      |   0.0 | 97.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.033562   | 0.033562   | 0.033562   |   0.0 |  0.33
Output  | 7.128e-05  | 7.128e-05  | 7.128e-05  |   0.0 |  0.00
Modify  | 0.14712    | 0.14712    | 0.14712    |   0.0 |  1.46
Other   |            | 0.0215     |            |       |  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:      223526.0 ave      223526 max      223526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223526
Ave neighs/atom = 111.76300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.939793217882, Press = -0.586147359557868
next a
jump SELF top
variable a loop 2000
run 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   -16068.889   -16068.889   -16134.438   -16134.438    253.68364    253.68364    36338.538    36338.538    1509.5812    1509.5812 
   58000   -16067.764   -16067.764   -16133.215   -16133.215    253.30034    253.30034    36380.078    36380.078   -274.59432   -274.59432 
Loop time of 10.1412 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.520 ns/day, 2.817 hours/ns, 98.608 timesteps/s
100.0% 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.9361     | 9.9361     | 9.9361     |   0.0 | 97.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034125   | 0.034125   | 0.034125   |   0.0 |  0.34
Output  | 0.00013556 | 0.00013556 | 0.00013556 |   0.0 |  0.00
Modify  | 0.14881    | 0.14881    | 0.14881    |   0.0 |  1.47
Other   |            | 0.02203    |            |       |  0.22

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:      223472.0 ave      223472 max      223472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223472
Ave neighs/atom = 111.73600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.953444686973, Press = -0.281078969211356
next a
jump SELF top
variable a loop 2000
run 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   -16067.764   -16067.764   -16133.215   -16133.215    253.30034    253.30034    36380.078    36380.078   -274.59432   -274.59432 
   59000   -16068.674   -16068.674   -16134.037   -16134.037      252.962      252.962    36383.298    36383.298   -862.25839   -862.25839 
Loop time of 9.94506 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.688 ns/day, 2.763 hours/ns, 100.552 timesteps/s
100.0% 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.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032447   | 0.032447   | 0.032447   |   0.0 |  0.33
Output  | 6.1766e-05 | 6.1766e-05 | 6.1766e-05 |   0.0 |  0.00
Modify  | 0.14005    | 0.14005    | 0.14005    |   0.0 |  1.41
Other   |            | 0.01944    |            |       |  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:      223468.0 ave      223468 max      223468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223468
Ave neighs/atom = 111.73400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.022913253621, Press = -0.685972051348977
next a
jump SELF top
variable a loop 2000
run 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   -16068.674   -16068.674   -16134.037   -16134.037      252.962      252.962    36383.298    36383.298   -862.25839   -862.25839 
   60000   -16068.471   -16068.471   -16134.859   -16134.859    256.92545    256.92545     36392.57     36392.57      -1402.5      -1402.5 
Loop time of 9.94654 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.686 ns/day, 2.763 hours/ns, 100.538 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.755      | 9.755      | 9.755      |   0.0 | 98.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03252    | 0.03252    | 0.03252    |   0.0 |  0.33
Output  | 6.1083e-05 | 6.1083e-05 | 6.1083e-05 |   0.0 |  0.00
Modify  | 0.13956    | 0.13956    | 0.13956    |   0.0 |  1.40
Other   |            | 0.01942    |            |       |  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:      223530.0 ave      223530 max      223530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223530
Ave neighs/atom = 111.76500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.018918349137, Press = -0.468264408836909
next a
jump SELF top
variable a loop 2000
run 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   -16068.471   -16068.471   -16134.859   -16134.859    256.92545    256.92545     36392.57     36392.57      -1402.5      -1402.5 
   61000   -16072.266   -16072.266   -16137.045   -16137.045     250.7011     250.7011    36309.146    36309.146    2477.7172    2477.7172 
Loop time of 10.374 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.329 ns/day, 2.882 hours/ns, 96.395 timesteps/s
100.0% 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.156     | 10.156     | 10.156     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035653   | 0.035653   | 0.035653   |   0.0 |  0.34
Output  | 6.9846e-05 | 6.9846e-05 | 6.9846e-05 |   0.0 |  0.00
Modify  | 0.15765    | 0.15765    | 0.15765    |   0.0 |  1.52
Other   |            | 0.02455    |            |       |  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:      223522.0 ave      223522 max      223522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223522
Ave neighs/atom = 111.76100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
36366.8548198843

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0