# 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 4.044650763273239*${_u_distance}
variable latticeconst_converted equal 4.044650763273239*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04465076327324
Lattice spacing in x,y,z = 4.0446508 4.0446508 4.0446508
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 (40.446508 40.446508 40.446508)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (40.446508 40.446508 40.446508)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeShimBaskes_2003_Al__MO_353977746962_000
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13288.467   -13288.467       -13440       -13440       293.15       293.15     66167.25     66167.25    2446.1515    2446.1515 
    1000   -13120.358   -13120.358   -13281.421   -13281.421    311.58758    311.58758    67342.825    67342.825    460.24888    460.24888 
Loop time of 131.292 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.658 ns/day, 36.470 hours/ns, 7.617 timesteps/s
99.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    | 130.86     | 130.86     | 130.86     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053      | 0.053      | 0.053      |   0.0 |  0.04
Output  | 0.0010567  | 0.0010567  | 0.0010567  |   0.0 |  0.00
Modify  | 0.32213    | 0.32213    | 0.32213    |   0.0 |  0.25
Other   |            | 0.05315    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312000.0 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13120.358   -13120.358   -13281.421   -13281.421    311.58758    311.58758    67342.825    67342.825    460.24888    460.24888 
    2000   -13137.099   -13137.099   -13284.832   -13284.832    285.79968    285.79968    67337.849    67337.849    55.575769    55.575769 
Loop time of 136.809 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.632 ns/day, 38.002 hours/ns, 7.309 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.37     | 136.37     | 136.37     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055138   | 0.055138   | 0.055138   |   0.0 |  0.04
Output  | 0.00013883 | 0.00013883 | 0.00013883 |   0.0 |  0.00
Modify  | 0.33087    | 0.33087    | 0.33087    |   0.0 |  0.24
Other   |            | 0.05368    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282292.0 ave      282292 max      282292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282292
Ave neighs/atom = 70.573000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13137.099   -13137.099   -13284.832   -13284.832    285.79968    285.79968    67337.849    67337.849    55.575769    55.575769 
    3000   -13126.302   -13126.302   -13273.049   -13273.049    283.89204    283.89204    67374.641    67374.641    377.59981    377.59981 
Loop time of 137.604 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.628 ns/day, 38.223 hours/ns, 7.267 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.17     | 137.17     | 137.17     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053444   | 0.053444   | 0.053444   |   0.0 |  0.04
Output  | 0.00013997 | 0.00013997 | 0.00013997 |   0.0 |  0.00
Modify  | 0.33083    | 0.33083    | 0.33083    |   0.0 |  0.24
Other   |            | 0.05262    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282664.0 ave      282664 max      282664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282664
Ave neighs/atom = 70.666000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13126.302   -13126.302   -13273.049   -13273.049    283.89204    283.89204    67374.641    67374.641    377.59981    377.59981 
    4000   -13134.176   -13134.176   -13282.226   -13282.226     286.4127     286.4127    67346.851    67346.851    57.550237    57.550237 
Loop time of 136.951 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.631 ns/day, 38.042 hours/ns, 7.302 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.52     | 136.52     | 136.52     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053413   | 0.053413   | 0.053413   |   0.0 |  0.04
Output  | 0.00017122 | 0.00017122 | 0.00017122 |   0.0 |  0.00
Modify  | 0.32878    | 0.32878    | 0.32878    |   0.0 |  0.24
Other   |            | 0.05137    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281420.0 ave      281420 max      281420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281420
Ave neighs/atom = 70.355000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13134.176   -13134.176   -13282.226   -13282.226     286.4127     286.4127    67346.851    67346.851    57.550237    57.550237 
    5000   -13130.352   -13130.352   -13279.931   -13279.931    289.37116    289.37116    67366.533    67366.533    80.270597    80.270597 
Loop time of 137.382 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.629 ns/day, 38.162 hours/ns, 7.279 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.95     | 136.95     | 136.95     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053708   | 0.053708   | 0.053708   |   0.0 |  0.04
Output  | 0.00024478 | 0.00024478 | 0.00024478 |   0.0 |  0.00
Modify  | 0.3296     | 0.3296     | 0.3296     |   0.0 |  0.24
Other   |            | 0.05098    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282340.0 ave      282340 max      282340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282340
Ave neighs/atom = 70.585000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 295.113469818419, Press = -251.259192603874
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13130.352   -13130.352   -13279.931   -13279.931    289.37116    289.37116    67366.533    67366.533    80.270597    80.270597 
    6000   -13129.899   -13129.899   -13279.701   -13279.701    289.80189    289.80189    67427.319    67427.319   -576.26407   -576.26407 
Loop time of 133.447 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.647 ns/day, 37.069 hours/ns, 7.494 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.01     | 133.01     | 133.01     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052268   | 0.052268   | 0.052268   |   0.0 |  0.04
Output  | 8.9902e-05 | 8.9902e-05 | 8.9902e-05 |   0.0 |  0.00
Modify  | 0.33287    | 0.33287    | 0.33287    |   0.0 |  0.25
Other   |            | 0.05296    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282124.0 ave      282124 max      282124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282124
Ave neighs/atom = 70.531000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.648676711596, Press = -30.5405607265143
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13129.899   -13129.899   -13279.701   -13279.701    289.80189    289.80189    67427.319    67427.319   -576.26407   -576.26407 
    7000   -13132.505   -13132.505   -13284.442   -13284.442    293.93294    293.93294    67483.951    67483.951   -1587.5618   -1587.5618 
Loop time of 138.765 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.623 ns/day, 38.546 hours/ns, 7.206 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.32     | 138.32     | 138.32     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052619   | 0.052619   | 0.052619   |   0.0 |  0.04
Output  | 0.00010858 | 0.00010858 | 0.00010858 |   0.0 |  0.00
Modify  | 0.34198    | 0.34198    | 0.34198    |   0.0 |  0.25
Other   |            | 0.05002    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281838.0 ave      281838 max      281838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281838
Ave neighs/atom = 70.459500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.165818519337, Press = -4.16237293888437
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13132.505   -13132.505   -13284.442   -13284.442    293.93294    293.93294    67483.951    67483.951   -1587.5618   -1587.5618 
    8000   -13129.222   -13129.222   -13284.649   -13284.649     300.6839     300.6839    67430.538    67430.538   -900.11085   -900.11085 
Loop time of 143.717 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.601 ns/day, 39.921 hours/ns, 6.958 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 143.26     | 143.26     | 143.26     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054321   | 0.054321   | 0.054321   |   0.0 |  0.04
Output  | 0.00017288 | 0.00017288 | 0.00017288 |   0.0 |  0.00
Modify  | 0.35496    | 0.35496    | 0.35496    |   0.0 |  0.25
Other   |            | 0.05216    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281374.0 ave      281374 max      281374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281374
Ave neighs/atom = 70.343500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.969967708666, Press = 5.88814660443929
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13129.222   -13129.222   -13284.649   -13284.649     300.6839     300.6839    67430.538    67430.538   -900.11085   -900.11085 
    9000   -13130.205   -13130.205   -13280.096   -13280.096    289.97518    289.97518    67344.611    67344.611    304.62047    304.62047 
Loop time of 144.691 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.597 ns/day, 40.192 hours/ns, 6.911 timesteps/s
99.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.23     | 144.23     | 144.23     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055455   | 0.055455   | 0.055455   |   0.0 |  0.04
Output  | 0.00012406 | 0.00012406 | 0.00012406 |   0.0 |  0.00
Modify  | 0.3564     | 0.3564     | 0.3564     |   0.0 |  0.25
Other   |            | 0.05399    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281800.0 ave      281800 max      281800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281800
Ave neighs/atom = 70.450000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.171866889628, Press = 2.57196436363461
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13130.205   -13130.205   -13280.096   -13280.096    289.97518    289.97518    67344.611    67344.611    304.62047    304.62047 
   10000   -13131.255   -13131.255   -13281.936   -13281.936     291.5023     291.5023    67334.324    67334.324    299.22187    299.22187 
Loop time of 145.217 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.595 ns/day, 40.338 hours/ns, 6.886 timesteps/s
98.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.75     | 144.75     | 144.75     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054834   | 0.054834   | 0.054834   |   0.0 |  0.04
Output  | 0.00011079 | 0.00011079 | 0.00011079 |   0.0 |  0.00
Modify  | 0.35503    | 0.35503    | 0.35503    |   0.0 |  0.24
Other   |            | 0.05229    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282684.0 ave      282684 max      282684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282684
Ave neighs/atom = 70.671000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.490505042916, Press = -2.45059107345743
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13131.255   -13131.255   -13281.936   -13281.936     291.5023     291.5023    67334.324    67334.324    299.22187    299.22187 
   11000   -13128.427   -13128.427   -13280.954   -13280.954    295.07301    295.07301    67367.676    67367.676    40.215596    40.215596 
Loop time of 142.561 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.606 ns/day, 39.600 hours/ns, 7.015 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.1      | 142.1      | 142.1      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053919   | 0.053919   | 0.053919   |   0.0 |  0.04
Output  | 0.0001092  | 0.0001092  | 0.0001092  |   0.0 |  0.00
Modify  | 0.35137    | 0.35137    | 0.35137    |   0.0 |  0.25
Other   |            | 0.05282    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282588.0 ave      282588 max      282588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282588
Ave neighs/atom = 70.647000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.481201673689, Press = -3.59386748822229
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13128.427   -13128.427   -13280.954   -13280.954    295.07301    295.07301    67367.676    67367.676    40.215596    40.215596 
   12000   -13133.067   -13133.067   -13281.942   -13281.942    288.00989    288.00989    67381.802    67381.802   -212.65147   -212.65147 
Loop time of 140.3 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.616 ns/day, 38.972 hours/ns, 7.128 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.85     | 139.85     | 139.85     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053479   | 0.053479   | 0.053479   |   0.0 |  0.04
Output  | 0.00016848 | 0.00016848 | 0.00016848 |   0.0 |  0.00
Modify  | 0.34517    | 0.34517    | 0.34517    |   0.0 |  0.25
Other   |            | 0.05051    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282088.0 ave      282088 max      282088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282088
Ave neighs/atom = 70.522000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.514208596041, Press = -3.81600041664177
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13133.067   -13133.067   -13281.942   -13281.942    288.00989    288.00989    67381.802    67381.802   -212.65147   -212.65147 
   13000   -13124.324   -13124.324     -13279.6     -13279.6    300.39133    300.39133    67470.294    67470.294   -937.93785   -937.93785 
Loop time of 138.88 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.622 ns/day, 38.578 hours/ns, 7.200 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.44     | 138.44     | 138.44     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053224   | 0.053224   | 0.053224   |   0.0 |  0.04
Output  | 9.9747e-05 | 9.9747e-05 | 9.9747e-05 |   0.0 |  0.00
Modify  | 0.33912    | 0.33912    | 0.33912    |   0.0 |  0.24
Other   |            | 0.05029    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282148.0 ave      282148 max      282148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282148
Ave neighs/atom = 70.537000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.675417588906, Press = -2.62378186258853
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13124.324   -13124.324     -13279.6     -13279.6    300.39133    300.39133    67470.294    67470.294   -937.93785   -937.93785 
   14000   -13134.343   -13134.343   -13284.079   -13284.079    289.67329    289.67329    67417.812    67417.812   -826.98569   -826.98569 
Loop time of 138.638 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.623 ns/day, 38.511 hours/ns, 7.213 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.2      | 138.2      | 138.2      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052843   | 0.052843   | 0.052843   |   0.0 |  0.04
Output  | 0.00010458 | 0.00010458 | 0.00010458 |   0.0 |  0.00
Modify  | 0.33928    | 0.33928    | 0.33928    |   0.0 |  0.24
Other   |            | 0.04986    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281380.0 ave      281380 max      281380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281380
Ave neighs/atom = 70.345000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.682331627123, Press = 1.22314446023992
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13134.343   -13134.343   -13284.079   -13284.079    289.67329    289.67329    67417.812    67417.812   -826.98569   -826.98569 
   15000   -13132.151   -13132.151   -13282.727   -13282.727    291.29989    291.29989    67366.284    67366.284   -119.53913   -119.53913 
Loop time of 139.741 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.618 ns/day, 38.817 hours/ns, 7.156 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.29     | 139.29     | 139.29     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053657   | 0.053657   | 0.053657   |   0.0 |  0.04
Output  | 0.00012413 | 0.00012413 | 0.00012413 |   0.0 |  0.00
Modify  | 0.34275    | 0.34275    | 0.34275    |   0.0 |  0.25
Other   |            | 0.05098    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281910.0 ave      281910 max      281910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281910
Ave neighs/atom = 70.477500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.485984539265, Press = 2.73270639099056
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13132.151   -13132.151   -13282.727   -13282.727    291.29989    291.29989    67366.284    67366.284   -119.53913   -119.53913 
   16000   -13131.699   -13131.699   -13284.792   -13284.792    296.16978    296.16978     67313.72     67313.72    367.15851    367.15851 
Loop time of 139.771 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.618 ns/day, 38.825 hours/ns, 7.155 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.32     | 139.32     | 139.32     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05331    | 0.05331    | 0.05331    |   0.0 |  0.04
Output  | 9.6909e-05 | 9.6909e-05 | 9.6909e-05 |   0.0 |  0.00
Modify  | 0.34264    | 0.34264    | 0.34264    |   0.0 |  0.25
Other   |            | 0.05092    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282392.0 ave      282392 max      282392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282392
Ave neighs/atom = 70.598000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.372371967389, Press = 0.183673937289286
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13131.699   -13131.699   -13284.792   -13284.792    296.16978    296.16978     67313.72     67313.72    367.15851    367.15851 
   17000    -13128.13    -13128.13    -13282.28    -13282.28    298.21366    298.21366    67345.569    67345.569    216.78058    216.78058 
Loop time of 139.735 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.618 ns/day, 38.815 hours/ns, 7.156 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.29     | 139.29     | 139.29     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053553   | 0.053553   | 0.053553   |   0.0 |  0.04
Output  | 0.00011068 | 0.00011068 | 0.00011068 |   0.0 |  0.00
Modify  | 0.34334    | 0.34334    | 0.34334    |   0.0 |  0.25
Other   |            | 0.05128    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282942.0 ave      282942 max      282942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282942
Ave neighs/atom = 70.735500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.376423608188, Press = -1.19797728999262
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000    -13128.13    -13128.13    -13282.28    -13282.28    298.21366    298.21366    67345.569    67345.569    216.78058    216.78058 
   18000    -13131.18    -13131.18   -13278.327   -13278.327      284.666      284.666    67325.489    67325.489    598.65708    598.65708 
Loop time of 139.442 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.620 ns/day, 38.734 hours/ns, 7.171 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139        | 139        | 139        |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053496   | 0.053496   | 0.053496   |   0.0 |  0.04
Output  | 0.00011198 | 0.00011198 | 0.00011198 |   0.0 |  0.00
Modify  | 0.34144    | 0.34144    | 0.34144    |   0.0 |  0.24
Other   |            | 0.04966    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282680.0 ave      282680 max      282680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282680
Ave neighs/atom = 70.670000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.233778981795, Press = -1.11792593097546
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000    -13131.18    -13131.18   -13278.327   -13278.327      284.666      284.666    67325.489    67325.489    598.65708    598.65708 
   19000   -13132.647   -13132.647   -13282.722   -13282.722    290.32987    290.32987    67316.005    67316.005    427.62228    427.62228 
Loop time of 141.226 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.612 ns/day, 39.229 hours/ns, 7.081 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.78     | 140.78     | 140.78     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05354    | 0.05354    | 0.05354    |   0.0 |  0.04
Output  | 9.7181e-05 | 9.7181e-05 | 9.7181e-05 |   0.0 |  0.00
Modify  | 0.3443     | 0.3443     | 0.3443     |   0.0 |  0.24
Other   |            | 0.04985    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282288.0 ave      282288 max      282288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282288
Ave neighs/atom = 70.572000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.251797424058, Press = -1.87415074970319
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13132.647   -13132.647   -13282.722   -13282.722    290.32987    290.32987    67316.005    67316.005    427.62228    427.62228 
   20000   -13129.301   -13129.301   -13281.636   -13281.636    294.70171    294.70171    67369.794    67369.794   -136.66865   -136.66865 
Loop time of 141.611 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.610 ns/day, 39.336 hours/ns, 7.062 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.16     | 141.16     | 141.16     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053787   | 0.053787   | 0.053787   |   0.0 |  0.04
Output  | 0.0001094  | 0.0001094  | 0.0001094  |   0.0 |  0.00
Modify  | 0.34698    | 0.34698    | 0.34698    |   0.0 |  0.25
Other   |            | 0.04968    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282508.0 ave      282508 max      282508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282508
Ave neighs/atom = 70.627000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.19430552264, Press = -4.31637654799593
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13129.301   -13129.301   -13281.636   -13281.636    294.70171    294.70171    67369.794    67369.794   -136.66865   -136.66865 
   21000   -13136.609   -13136.609    -13286.43    -13286.43    289.83882    289.83882    67421.532    67421.532   -1037.2077   -1037.2077 
Loop time of 141.428 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.611 ns/day, 39.286 hours/ns, 7.071 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.97     | 140.97     | 140.97     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054433   | 0.054433   | 0.054433   |   0.0 |  0.04
Output  | 0.00011086 | 0.00011086 | 0.00011086 |   0.0 |  0.00
Modify  | 0.35039    | 0.35039    | 0.35039    |   0.0 |  0.25
Other   |            | 0.05432    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281782.0 ave      281782 max      281782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281782
Ave neighs/atom = 70.445500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.090625255039, Press = -2.59742852809629
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13136.609   -13136.609    -13286.43    -13286.43    289.83882    289.83882    67421.532    67421.532   -1037.2077   -1037.2077 
   22000    -13128.36    -13128.36   -13279.721   -13279.721    292.81814    292.81814    67446.274    67446.274   -803.09647   -803.09647 
Loop time of 142.16 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.608 ns/day, 39.489 hours/ns, 7.034 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.69     | 141.69     | 141.69     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055675   | 0.055675   | 0.055675   |   0.0 |  0.04
Output  | 0.00010945 | 0.00010945 | 0.00010945 |   0.0 |  0.00
Modify  | 0.35395    | 0.35395    | 0.35395    |   0.0 |  0.25
Other   |            | 0.05723    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282270.0 ave      282270 max      282270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282270
Ave neighs/atom = 70.567500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.016485667244, Press = -0.617468907293638
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000    -13128.36    -13128.36   -13279.721   -13279.721    292.81814    292.81814    67446.274    67446.274   -803.09647   -803.09647 
   23000   -13130.699   -13130.699   -13284.266   -13284.266    297.08637    297.08637    67393.714    67393.714   -468.04509   -468.04509 
Loop time of 140.314 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.616 ns/day, 38.976 hours/ns, 7.127 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.85     | 139.85     | 139.85     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056286   | 0.056286   | 0.056286   |   0.0 |  0.04
Output  | 0.00011164 | 0.00011164 | 0.00011164 |   0.0 |  0.00
Modify  | 0.34926    | 0.34926    | 0.34926    |   0.0 |  0.25
Other   |            | 0.05663    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281514.0 ave      281514 max      281514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281514
Ave neighs/atom = 70.378500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.958754224908, Press = 0.365107120522731
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13130.699   -13130.699   -13284.266   -13284.266    297.08637    297.08637    67393.714    67393.714   -468.04509   -468.04509 
   24000   -13129.608   -13129.608   -13280.442   -13280.442    291.79814    291.79814    67352.399    67352.399    162.69275    162.69275 
Loop time of 143.595 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.602 ns/day, 39.888 hours/ns, 6.964 timesteps/s
99.2% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 143.13     | 143.13     | 143.13     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055933   | 0.055933   | 0.055933   |   0.0 |  0.04
Output  | 0.00010439 | 0.00010439 | 0.00010439 |   0.0 |  0.00
Modify  | 0.35832    | 0.35832    | 0.35832    |   0.0 |  0.25
Other   |            | 0.05515    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282330.0 ave      282330 max      282330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282330
Ave neighs/atom = 70.582500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.956649687834, Press = 0.571507179694308
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13129.608   -13129.608   -13280.442   -13280.442    291.79814    291.79814    67352.399    67352.399    162.69275    162.69275 
   25000    -13133.59    -13133.59   -13286.586   -13286.586    295.98012    295.98012    67269.161    67269.161    759.03312    759.03312 
Loop time of 140.785 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.614 ns/day, 39.107 hours/ns, 7.103 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.34     | 140.34     | 140.34     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053342   | 0.053342   | 0.053342   |   0.0 |  0.04
Output  | 9.2564e-05 | 9.2564e-05 | 9.2564e-05 |   0.0 |  0.00
Modify  | 0.34511    | 0.34511    | 0.34511    |   0.0 |  0.25
Other   |            | 0.05002    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282460.0 ave      282460 max      282460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282460
Ave neighs/atom = 70.615000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.050836204822, Press = 0.624044513447025
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000    -13133.59    -13133.59   -13286.586   -13286.586    295.98012    295.98012    67269.161    67269.161    759.03312    759.03312 
   26000    -13129.58    -13129.58   -13282.197   -13282.197    295.24719    295.24719    67195.754    67195.754     1867.697     1867.697 
Loop time of 140.456 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.615 ns/day, 39.015 hours/ns, 7.120 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.01     | 140.01     | 140.01     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053582   | 0.053582   | 0.053582   |   0.0 |  0.04
Output  | 0.00010807 | 0.00010807 | 0.00010807 |   0.0 |  0.00
Modify  | 0.34449    | 0.34449    | 0.34449    |   0.0 |  0.25
Other   |            | 0.04998    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      283540.0 ave      283540 max      283540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283540
Ave neighs/atom = 70.885000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.032065331529, Press = -0.716066462566133
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000    -13129.58    -13129.58   -13282.197   -13282.197    295.24719    295.24719    67195.754    67195.754     1867.697     1867.697 
   27000   -13134.979   -13134.979   -13283.439   -13283.439    287.20481    287.20481    67287.577    67287.577    618.47151    618.47151 
Loop time of 140.318 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.616 ns/day, 38.977 hours/ns, 7.127 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.87     | 139.87     | 139.87     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053301   | 0.053301   | 0.053301   |   0.0 |  0.04
Output  | 0.0001039  | 0.0001039  | 0.0001039  |   0.0 |  0.00
Modify  | 0.34233    | 0.34233    | 0.34233    |   0.0 |  0.24
Other   |            | 0.04984    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      283952.0 ave      283952 max      283952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283952
Ave neighs/atom = 70.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.956219530581, Press = -1.6825080844966
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13134.979   -13134.979   -13283.439   -13283.439    287.20481    287.20481    67287.577    67287.577    618.47151    618.47151 
   28000   -13127.543   -13127.543   -13281.933   -13281.933    298.67953    298.67953    67382.194    67382.194   -218.64846   -218.64846 
Loop time of 139.457 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.620 ns/day, 38.738 hours/ns, 7.171 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.01     | 139.01     | 139.01     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053198   | 0.053198   | 0.053198   |   0.0 |  0.04
Output  | 0.00010239 | 0.00010239 | 0.00010239 |   0.0 |  0.00
Modify  | 0.34001    | 0.34001    | 0.34001    |   0.0 |  0.24
Other   |            | 0.04967    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      283032.0 ave      283032 max      283032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283032
Ave neighs/atom = 70.758000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.927881783062, Press = -1.14680616355489
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13127.543   -13127.543   -13281.933   -13281.933    298.67953    298.67953    67382.194    67382.194   -218.64846   -218.64846 
   29000    -13129.17    -13129.17   -13280.481   -13280.481    292.72253    292.72253    67404.538    67404.538   -411.86262   -411.86262 
Loop time of 140.135 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.617 ns/day, 38.926 hours/ns, 7.136 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.69     | 139.69     | 139.69     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053566   | 0.053566   | 0.053566   |   0.0 |  0.04
Output  | 0.00010959 | 0.00010959 | 0.00010959 |   0.0 |  0.00
Modify  | 0.34339    | 0.34339    | 0.34339    |   0.0 |  0.25
Other   |            | 0.0503     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282274.0 ave      282274 max      282274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282274
Ave neighs/atom = 70.568500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.950469840868, Press = -1.10231193053451
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    -13129.17    -13129.17   -13280.481   -13280.481    292.72253    292.72253    67404.538    67404.538   -411.86262   -411.86262 
   30000   -13132.957   -13132.957   -13282.507   -13282.507    289.31313    289.31313    67411.886    67411.886   -669.47303   -669.47303 
Loop time of 139.872 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.618 ns/day, 38.853 hours/ns, 7.149 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.43     | 139.43     | 139.43     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053132   | 0.053132   | 0.053132   |   0.0 |  0.04
Output  | 0.00010306 | 0.00010306 | 0.00010306 |   0.0 |  0.00
Modify  | 0.3419     | 0.3419     | 0.3419     |   0.0 |  0.24
Other   |            | 0.04972    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281750.0 ave      281750 max      281750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281750
Ave neighs/atom = 70.437500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.041090932343, Press = -0.405636680175973
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13132.957   -13132.957   -13282.507   -13282.507    289.31313    289.31313    67411.886    67411.886   -669.47303   -669.47303 
   31000   -13131.079   -13131.079   -13280.228   -13280.228    288.53866    288.53866     67489.31     67489.31   -1397.4609   -1397.4609 
Loop time of 136.798 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.632 ns/day, 37.999 hours/ns, 7.310 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.36     | 136.36     | 136.36     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052467   | 0.052467   | 0.052467   |   0.0 |  0.04
Output  | 0.00011128 | 0.00011128 | 0.00011128 |   0.0 |  0.00
Modify  | 0.33527    | 0.33527    | 0.33527    |   0.0 |  0.25
Other   |            | 0.04996    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281960.0 ave      281960 max      281960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281960
Ave neighs/atom = 70.490000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.043927896085, Press = 1.07419853538319
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13131.079   -13131.079   -13280.228   -13280.228    288.53866    288.53866     67489.31     67489.31   -1397.4609   -1397.4609 
   32000   -13130.632   -13130.632   -13281.966   -13281.966    292.76622    292.76622    67360.543    67360.543   -1.0655554   -1.0655554 
Loop time of 137.004 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.631 ns/day, 38.057 hours/ns, 7.299 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.56     | 136.56     | 136.56     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0526     | 0.0526     | 0.0526     |   0.0 |  0.04
Output  | 0.00010176 | 0.00010176 | 0.00010176 |   0.0 |  0.00
Modify  | 0.33743    | 0.33743    | 0.33743    |   0.0 |  0.25
Other   |            | 0.05039    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281044.0 ave      281044 max      281044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281044
Ave neighs/atom = 70.261000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.975562716782, Press = 1.68674640652077
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13130.632   -13130.632   -13281.966   -13281.966    292.76622    292.76622    67360.543    67360.543   -1.0655554   -1.0655554 
   33000   -13133.389   -13133.389    -13284.85    -13284.85    293.01129    293.01129    67295.781    67295.781    552.47991    552.47991 
Loop time of 138.748 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.623 ns/day, 38.541 hours/ns, 7.207 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.3      | 138.3      | 138.3      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052974   | 0.052974   | 0.052974   |   0.0 |  0.04
Output  | 0.00010942 | 0.00010942 | 0.00010942 |   0.0 |  0.00
Modify  | 0.34204    | 0.34204    | 0.34204    |   0.0 |  0.25
Other   |            | 0.05019    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282278.0 ave      282278 max      282278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282278
Ave neighs/atom = 70.569500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.941068829298, Press = 0.770095686668277
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13133.389   -13133.389    -13284.85    -13284.85    293.01129    293.01129    67295.781    67295.781    552.47991    552.47991 
   34000    -13128.22    -13128.22   -13281.823   -13281.823     297.1564     297.1564    67318.769    67318.769    481.31686    481.31686 
Loop time of 138.992 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.622 ns/day, 38.609 hours/ns, 7.195 timesteps/s
99.2% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.54     | 138.54     | 138.54     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065644   | 0.065644   | 0.065644   |   0.0 |  0.05
Output  | 9.7508e-05 | 9.7508e-05 | 9.7508e-05 |   0.0 |  0.00
Modify  | 0.33784    | 0.33784    | 0.33784    |   0.0 |  0.24
Other   |            | 0.05335    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      283222.0 ave      283222 max      283222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283222
Ave neighs/atom = 70.805500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.88607057917, Press = -0.234788520217938
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000    -13128.22    -13128.22   -13281.823   -13281.823     297.1564     297.1564    67318.769    67318.769    481.31686    481.31686 
   35000   -13130.275   -13130.275   -13280.327   -13280.327    290.28747    290.28747     67324.16     67324.16    471.95681    471.95681 
Loop time of 137.839 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.627 ns/day, 38.289 hours/ns, 7.255 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.4      | 137.4      | 137.4      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052313   | 0.052313   | 0.052313   |   0.0 |  0.04
Output  | 0.00010265 | 0.00010265 | 0.00010265 |   0.0 |  0.00
Modify  | 0.33841    | 0.33841    | 0.33841    |   0.0 |  0.25
Other   |            | 0.04905    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282558.0 ave      282558 max      282558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282558
Ave neighs/atom = 70.639500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.883434525405, Press = -0.570264019141558
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13130.275   -13130.275   -13280.327   -13280.327    290.28747    290.28747     67324.16     67324.16    471.95681    471.95681 
   36000    -13128.64    -13128.64   -13283.068   -13283.068    298.75215    298.75215    67362.243    67362.243   -55.713325   -55.713325 
Loop time of 139.659 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.619 ns/day, 38.794 hours/ns, 7.160 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.21     | 139.21     | 139.21     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053121   | 0.053121   | 0.053121   |   0.0 |  0.04
Output  | 9.8067e-05 | 9.8067e-05 | 9.8067e-05 |   0.0 |  0.00
Modify  | 0.34449    | 0.34449    | 0.34449    |   0.0 |  0.25
Other   |            | 0.05193    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282570.0 ave      282570 max      282570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282570
Ave neighs/atom = 70.642500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.97171623676, Press = -0.591955538527229
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000    -13128.64    -13128.64   -13283.068   -13283.068    298.75215    298.75215    67362.243    67362.243   -55.713325   -55.713325 
   37000   -13129.327   -13129.327   -13280.605   -13280.605    292.65789    292.65789    67387.047    67387.047   -195.50881   -195.50881 
Loop time of 135.645 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.637 ns/day, 37.679 hours/ns, 7.372 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.21     | 135.21     | 135.21     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052171   | 0.052171   | 0.052171   |   0.0 |  0.04
Output  | 9.9633e-05 | 9.9633e-05 | 9.9633e-05 |   0.0 |  0.00
Modify  | 0.33283    | 0.33283    | 0.33283    |   0.0 |  0.25
Other   |            | 0.04994    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282448.0 ave      282448 max      282448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282448
Ave neighs/atom = 70.612000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.006013250509, Press = -0.913208572270524
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13129.327   -13129.327   -13280.605   -13280.605    292.65789    292.65789    67387.047    67387.047   -195.50881   -195.50881 
   38000   -13127.043   -13127.043   -13280.367   -13280.367    296.61576    296.61576    67446.639    67446.639   -849.25976   -849.25976 
Loop time of 138.28 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.625 ns/day, 38.411 hours/ns, 7.232 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.84     | 137.84     | 137.84     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052817   | 0.052817   | 0.052817   |   0.0 |  0.04
Output  | 9.8373e-05 | 9.8373e-05 | 9.8373e-05 |   0.0 |  0.00
Modify  | 0.34       | 0.34       | 0.34       |   0.0 |  0.25
Other   |            | 0.04937    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281864.0 ave      281864 max      281864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281864
Ave neighs/atom = 70.466000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.08226245507, Press = -0.885934387778545
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13127.043   -13127.043   -13280.367   -13280.367    296.61576    296.61576    67446.639    67446.639   -849.25976   -849.25976 
   39000   -13132.592   -13132.592   -13279.946   -13279.946    285.06553    285.06553    67451.746    67451.746   -936.55816   -936.55816 
Loop time of 135.497 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.638 ns/day, 37.638 hours/ns, 7.380 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.06     | 135.06     | 135.06     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051744   | 0.051744   | 0.051744   |   0.0 |  0.04
Output  | 0.00011147 | 0.00011147 | 0.00011147 |   0.0 |  0.00
Modify  | 0.33218    | 0.33218    | 0.33218    |   0.0 |  0.25
Other   |            | 0.04955    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281326.0 ave      281326 max      281326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281326
Ave neighs/atom = 70.331500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.102957682779, Press = -0.258535078978225
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13132.592   -13132.592   -13279.946   -13279.946    285.06553    285.06553    67451.746    67451.746   -936.55816   -936.55816 
   40000   -13128.555   -13128.555   -13281.009   -13281.009    294.93273    294.93273    67439.363    67439.363   -743.95105   -743.95105 
Loop time of 135.909 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.636 ns/day, 37.752 hours/ns, 7.358 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.47     | 135.47     | 135.47     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052035   | 0.052035   | 0.052035   |   0.0 |  0.04
Output  | 9.5772e-05 | 9.5772e-05 | 9.5772e-05 |   0.0 |  0.00
Modify  | 0.33524    | 0.33524    | 0.33524    |   0.0 |  0.25
Other   |            | 0.04951    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281204.0 ave      281204 max      281204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281204
Ave neighs/atom = 70.301000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.084328843149, Press = 0.688146418854047
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13128.555   -13128.555   -13281.009   -13281.009    294.93273    294.93273    67439.363    67439.363   -743.95105   -743.95105 
   41000   -13129.614   -13129.614   -13283.909   -13283.909    298.49313    298.49313    67362.532    67362.532   -124.15581   -124.15581 
Loop time of 137.155 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.630 ns/day, 38.099 hours/ns, 7.291 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.72     | 136.72     | 136.72     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052141   | 0.052141   | 0.052141   |   0.0 |  0.04
Output  | 0.00013087 | 0.00013087 | 0.00013087 |   0.0 |  0.00
Modify  | 0.33617    | 0.33617    | 0.33617    |   0.0 |  0.25
Other   |            | 0.04962    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281716.0 ave      281716 max      281716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281716
Ave neighs/atom = 70.429000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.059269978898, Press = 0.362642340636588
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13129.614   -13129.614   -13283.909   -13283.909    298.49313    298.49313    67362.532    67362.532   -124.15581   -124.15581 
   42000   -13135.707   -13135.707     -13286.1     -13286.1     290.9445     290.9445    67314.334    67314.334    197.95972    197.95972 
Loop time of 136.986 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.631 ns/day, 38.052 hours/ns, 7.300 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.53     | 136.53     | 136.53     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053231   | 0.053231   | 0.053231   |   0.0 |  0.04
Output  | 0.00010285 | 0.00010285 | 0.00010285 |   0.0 |  0.00
Modify  | 0.34379    | 0.34379    | 0.34379    |   0.0 |  0.25
Other   |            | 0.05619    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      282310.0 ave      282310 max      282310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0