# 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.005 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_JeongParkDo_2018_PdAl__MO_616482358807_001
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_616482358807_001#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.24889    460.24889 
Loop time of 370.071 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.797 hours/ns, 2.702 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    | 369.04     | 369.04     | 369.04     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16165    | 0.16165    | 0.16165    |   0.0 |  0.04
Output  | 0.00022774 | 0.00022774 | 0.00022774 |   0.0 |  0.00
Modify  | 0.76575    | 0.76575    | 0.76575    |   0.0 |  0.21
Other   |            | 0.1048     |            |       |  0.03

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.24889    460.24889 
    2000   -13137.099   -13137.099   -13284.832   -13284.832    285.79968    285.79968    67337.849    67337.849    55.575816    55.575816 
Loop time of 382.721 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.311 hours/ns, 2.613 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 381.64     | 381.64     | 381.64     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16521    | 0.16521    | 0.16521    |   0.0 |  0.04
Output  | 0.00026606 | 0.00026606 | 0.00026606 |   0.0 |  0.00
Modify  | 0.80369    | 0.80369    | 0.80369    |   0.0 |  0.21
Other   |            | 0.1089     |            |       |  0.03

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.575816    55.575816 
    3000   -13126.302   -13126.302   -13273.049   -13273.049    283.89204    283.89204    67374.641    67374.641    377.59978    377.59978 
Loop time of 373.826 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.841 hours/ns, 2.675 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372.78     | 372.78     | 372.78     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16174    | 0.16174    | 0.16174    |   0.0 |  0.04
Output  | 0.00021808 | 0.00021808 | 0.00021808 |   0.0 |  0.00
Modify  | 0.77447    | 0.77447    | 0.77447    |   0.0 |  0.21
Other   |            | 0.107      |            |       |  0.03

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.59978    377.59978 
    4000   -13134.176   -13134.176   -13282.226   -13282.226     286.4127     286.4127    67346.851    67346.851    57.550229    57.550229 
Loop time of 331.021 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.950 hours/ns, 3.021 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 330.14     | 330.14     | 330.14     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14615    | 0.14615    | 0.14615    |   0.0 |  0.04
Output  | 0.00025265 | 0.00025265 | 0.00025265 |   0.0 |  0.00
Modify  | 0.64129    | 0.64129    | 0.64129    |   0.0 |  0.19
Other   |            | 0.09554    |            |       |  0.03

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.550229    57.550229 
    5000   -13130.352   -13130.352   -13279.931   -13279.931    289.37116    289.37116    67366.533    67366.533    80.270629    80.270629 
Loop time of 345.074 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.250 ns/day, 95.854 hours/ns, 2.898 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 344.14     | 344.14     | 344.14     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15122    | 0.15122    | 0.15122    |   0.0 |  0.04
Output  | 0.00017759 | 0.00017759 | 0.00017759 |   0.0 |  0.00
Modify  | 0.68875    | 0.68875    | 0.68875    |   0.0 |  0.20
Other   |            | 0.0985     |            |       |  0.03

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.113469595809, Press = -251.259183226589
next a
jump SELF top
variable a loop 2000
run 1000
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.270629    80.270629 
    6000   -13129.899   -13129.899   -13279.701   -13279.701    289.80189    289.80189    67427.319    67427.319   -576.26393   -576.26393 
Loop time of 383.997 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.666 hours/ns, 2.604 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 382.9      | 382.9      | 382.9      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16472    | 0.16472    | 0.16472    |   0.0 |  0.04
Output  | 0.00028218 | 0.00028218 | 0.00028218 |   0.0 |  0.00
Modify  | 0.82619    | 0.82619    | 0.82619    |   0.0 |  0.22
Other   |            | 0.1082     |            |       |  0.03

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.648676694165, Press = -30.5405621217436
next a
jump SELF top
variable a loop 2000
run 1000
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.26393   -576.26393 
    7000   -13132.505   -13132.505   -13284.442   -13284.442    293.93294    293.93294    67483.951    67483.951   -1587.5619   -1587.5619 
Loop time of 338.164 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 93.934 hours/ns, 2.957 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.23     | 337.23     | 337.23     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1482     | 0.1482     | 0.1482     |   0.0 |  0.04
Output  | 0.00017843 | 0.00017843 | 0.00017843 |   0.0 |  0.00
Modify  | 0.69121    | 0.69121    | 0.69121    |   0.0 |  0.20
Other   |            | 0.09721    |            |       |  0.03

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.16581851598, Press = -4.16237662521135
next a
jump SELF top
variable a loop 2000
run 1000
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.5619   -1587.5619 
    8000   -13129.222   -13129.222   -13284.649   -13284.649     300.6839     300.6839    67430.538    67430.538   -900.11101   -900.11101 
Loop time of 330.789 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.886 hours/ns, 3.023 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 329.88     | 329.88     | 329.88     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1455     | 0.1455     | 0.1455     |   0.0 |  0.04
Output  | 0.00017809 | 0.00017809 | 0.00017809 |   0.0 |  0.00
Modify  | 0.66695    | 0.66695    | 0.66695    |   0.0 |  0.20
Other   |            | 0.09418    |            |       |  0.03

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.969967752312, Press = 5.88814504934923
next a
jump SELF top
variable a loop 2000
run 1000
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.11101   -900.11101 
    9000   -13130.205   -13130.205   -13280.096   -13280.096    289.97518    289.97518    67344.611    67344.611    304.62038    304.62038 
Loop time of 370.799 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 103.000 hours/ns, 2.697 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    | 369.75     | 369.75     | 369.75     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16197    | 0.16197    | 0.16197    |   0.0 |  0.04
Output  | 0.00032628 | 0.00032628 | 0.00032628 |   0.0 |  0.00
Modify  | 0.78572    | 0.78572    | 0.78572    |   0.0 |  0.21
Other   |            | 0.1047     |            |       |  0.03

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.171866895761, Press = 2.57196454226811
next a
jump SELF top
variable a loop 2000
run 1000
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.62038    304.62038 
   10000   -13131.255   -13131.255   -13281.936   -13281.936    291.50231    291.50231    67334.324    67334.324    299.22145    299.22145 
Loop time of 384.722 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.867 hours/ns, 2.599 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    | 383.61     | 383.61     | 383.61     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16674    | 0.16674    | 0.16674    |   0.0 |  0.04
Output  | 0.00022134 | 0.00022134 | 0.00022134 |   0.0 |  0.00
Modify  | 0.83376    | 0.83376    | 0.83376    |   0.0 |  0.22
Other   |            | 0.1075     |            |       |  0.03

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.490505131016, Press = -2.45059087311464
next a
jump SELF top
variable a loop 2000
run 1000
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.50231    291.50231    67334.324    67334.324    299.22145    299.22145 
   11000   -13128.427   -13128.427   -13280.954   -13280.954      295.073      295.073    67367.676    67367.676    40.215433    40.215433 
Loop time of 380.407 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.669 hours/ns, 2.629 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 379.31     | 379.31     | 379.31     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16401    | 0.16401    | 0.16401    |   0.0 |  0.04
Output  | 0.00018056 | 0.00018056 | 0.00018056 |   0.0 |  0.00
Modify  | 0.82253    | 0.82253    | 0.82253    |   0.0 |  0.22
Other   |            | 0.1071     |            |       |  0.03

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.481201716565, Press = -3.59386517983697
next a
jump SELF top
variable a loop 2000
run 1000
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.073      295.073    67367.676    67367.676    40.215433    40.215433 
   12000   -13133.067   -13133.067   -13281.942   -13281.942    288.00989    288.00989    67381.803    67381.803   -212.65157   -212.65157 
Loop time of 384.558 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.822 hours/ns, 2.600 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    | 383.45     | 383.45     | 383.45     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16562    | 0.16562    | 0.16562    |   0.0 |  0.04
Output  | 0.00023832 | 0.00023832 | 0.00023832 |   0.0 |  0.00
Modify  | 0.82965    | 0.82965    | 0.82965    |   0.0 |  0.22
Other   |            | 0.1078     |            |       |  0.03

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.514208327595, Press = -3.81599246628644
next a
jump SELF top
variable a loop 2000
run 1000
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.803    67381.803   -212.65157   -212.65157 
   13000   -13124.324   -13124.324     -13279.6     -13279.6    300.39127    300.39127    67470.293    67470.293   -937.93394   -937.93394 
Loop time of 384.443 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.790 hours/ns, 2.601 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.34     | 383.34     | 383.34     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16647    | 0.16647    | 0.16647    |   0.0 |  0.04
Output  | 0.00023183 | 0.00023183 | 0.00023183 |   0.0 |  0.00
Modify  | 0.83168    | 0.83168    | 0.83168    |   0.0 |  0.22
Other   |            | 0.108      |            |       |  0.03

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.675418704274, Press = -2.62377766849278
next a
jump SELF top
variable a loop 2000
run 1000
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.39127    300.39127    67470.293    67470.293   -937.93394   -937.93394 
   14000   -13134.343   -13134.343   -13284.079   -13284.079    289.67326    289.67326    67417.812    67417.812   -826.98452   -826.98452 
Loop time of 383.907 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.641 hours/ns, 2.605 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 382.8      | 382.8      | 382.8      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16502    | 0.16502    | 0.16502    |   0.0 |  0.04
Output  | 0.00025281 | 0.00025281 | 0.00025281 |   0.0 |  0.00
Modify  | 0.83025    | 0.83025    | 0.83025    |   0.0 |  0.22
Other   |            | 0.1077     |            |       |  0.03

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.682331012165, Press = 1.22315270663735
next a
jump SELF top
variable a loop 2000
run 1000
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.67326    289.67326    67417.812    67417.812   -826.98452   -826.98452 
   15000   -13132.151   -13132.151   -13282.727   -13282.727    291.29986    291.29986    67366.283    67366.283   -119.53489   -119.53489 
Loop time of 385.686 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.135 hours/ns, 2.593 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    | 384.58     | 384.58     | 384.58     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16473    | 0.16473    | 0.16473    |   0.0 |  0.04
Output  | 0.0005771  | 0.0005771  | 0.0005771  |   0.0 |  0.00
Modify  | 0.82832    | 0.82832    | 0.82832    |   0.0 |  0.21
Other   |            | 0.1088     |            |       |  0.03

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.485985919675, Press = 2.73271462839924
next a
jump SELF top
variable a loop 2000
run 1000
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.29986    291.29986    67366.283    67366.283   -119.53489   -119.53489 
   16000   -13131.699   -13131.699   -13284.792   -13284.792     296.1698     296.1698    67313.719    67313.719     367.1629     367.1629 
Loop time of 373.066 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.629 hours/ns, 2.680 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    | 372.01     | 372.01     | 372.01     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16212    | 0.16212    | 0.16212    |   0.0 |  0.04
Output  | 0.00018122 | 0.00018122 | 0.00018122 |   0.0 |  0.00
Modify  | 0.79182    | 0.79182    | 0.79182    |   0.0 |  0.21
Other   |            | 0.1058     |            |       |  0.03

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.372372413869, Press = 0.18367054674154
next a
jump SELF top
variable a loop 2000
run 1000
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.1698     296.1698    67313.719    67313.719     367.1629     367.1629 
   17000    -13128.13    -13128.13    -13282.28    -13282.28    298.21366    298.21366    67345.568    67345.568    216.78799    216.78799 
Loop time of 374.028 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.897 hours/ns, 2.674 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    | 372.97     | 372.97     | 372.97     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1613     | 0.1613     | 0.1613     |   0.0 |  0.04
Output  | 0.00017783 | 0.00017783 | 0.00017783 |   0.0 |  0.00
Modify  | 0.78854    | 0.78854    | 0.78854    |   0.0 |  0.21
Other   |            | 0.1062     |            |       |  0.03

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.376428326485, Press = -1.19796027876495
next a
jump SELF top
variable a loop 2000
run 1000
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.568    67345.568    216.78799    216.78799 
   18000    -13131.18    -13131.18   -13278.327   -13278.327    284.66585    284.66585    67325.486    67325.486    598.67045    598.67045 
Loop time of 362.799 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.777 hours/ns, 2.756 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 361.77     | 361.77     | 361.77     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15907    | 0.15907    | 0.15907    |   0.0 |  0.04
Output  | 0.00018193 | 0.00018193 | 0.00018193 |   0.0 |  0.00
Modify  | 0.76709    | 0.76709    | 0.76709    |   0.0 |  0.21
Other   |            | 0.1031     |            |       |  0.03

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.233781293916, Press = -1.11788406594092
next a
jump SELF top
variable a loop 2000
run 1000
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.66585    284.66585    67325.486    67325.486    598.67045    598.67045 
   19000   -13132.646   -13132.646   -13282.721   -13282.721    290.33104    290.33104    67316.014    67316.014     427.5871     427.5871 
Loop time of 342.18 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.050 hours/ns, 2.922 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 341.23     | 341.23     | 341.23     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15085    | 0.15085    | 0.15085    |   0.0 |  0.04
Output  | 0.00025302 | 0.00025302 | 0.00025302 |   0.0 |  0.00
Modify  | 0.69936    | 0.69936    | 0.69936    |   0.0 |  0.20
Other   |            | 0.09751    |            |       |  0.03

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.251815465469, Press = -1.87407335941831
next a
jump SELF top
variable a loop 2000
run 1000
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.646   -13132.646   -13282.721   -13282.721    290.33104    290.33104    67316.014    67316.014     427.5871     427.5871 
   20000     -13129.3     -13129.3   -13281.636   -13281.636    294.70256    294.70256    67369.805    67369.805   -136.73667   -136.73667 
Loop time of 373.52 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.756 hours/ns, 2.677 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372.46     | 372.46     | 372.46     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16158    | 0.16158    | 0.16158    |   0.0 |  0.04
Output  | 0.00017867 | 0.00017867 | 0.00017867 |   0.0 |  0.00
Modify  | 0.7927     | 0.7927     | 0.7927     |   0.0 |  0.21
Other   |            | 0.1055     |            |       |  0.03

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.194352205356, Press = -4.31610906826328
next a
jump SELF top
variable a loop 2000
run 1000
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.3     -13129.3   -13281.636   -13281.636    294.70256    294.70256    67369.805    67369.805   -136.73667   -136.73667 
   21000    -13136.61    -13136.61    -13286.43    -13286.43    289.83768    289.83768    67421.548    67421.548   -1037.4146   -1037.4146 
Loop time of 355.123 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.243 ns/day, 98.645 hours/ns, 2.816 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    | 354.13     | 354.13     | 354.13     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15563    | 0.15563    | 0.15563    |   0.0 |  0.04
Output  | 0.00025452 | 0.00025452 | 0.00025452 |   0.0 |  0.00
Modify  | 0.73944    | 0.73944    | 0.73944    |   0.0 |  0.21
Other   |            | 0.1022     |            |       |  0.03

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.090627435629, Press = -2.59746297896808
next a
jump SELF top
variable a loop 2000
run 1000
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.61    -13136.61    -13286.43    -13286.43    289.83768    289.83768    67421.548    67421.548   -1037.4146   -1037.4146 
   22000   -13128.367   -13128.367   -13279.725   -13279.725    292.81095    292.81095    67446.246    67446.246   -803.11979   -803.11979 
Loop time of 373.684 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.801 hours/ns, 2.676 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372.62     | 372.62     | 372.62     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16338    | 0.16338    | 0.16338    |   0.0 |  0.04
Output  | 0.00017954 | 0.00017954 | 0.00017954 |   0.0 |  0.00
Modify  | 0.79396    | 0.79396    | 0.79396    |   0.0 |  0.21
Other   |            | 0.1049     |            |       |  0.03

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.016413008705, Press = -0.615112881543189
next a
jump SELF top
variable a loop 2000
run 1000
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.367   -13128.367   -13279.725   -13279.725    292.81095    292.81095    67446.246    67446.246   -803.11979   -803.11979 
   23000   -13130.701   -13130.701   -13284.268   -13284.268    297.08584    297.08584    67393.623    67393.623   -467.13362   -467.13362 
Loop time of 374.705 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 104.085 hours/ns, 2.669 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    | 373.63     | 373.63     | 373.63     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16463    | 0.16463    | 0.16463    |   0.0 |  0.04
Output  | 0.00021944 | 0.00021944 | 0.00021944 |   0.0 |  0.00
Modify  | 0.80438    | 0.80438    | 0.80438    |   0.0 |  0.21
Other   |            | 0.1073     |            |       |  0.03

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.958797655895, Press = 0.365932375756417
next a
jump SELF top
variable a loop 2000
run 1000
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.701   -13130.701   -13284.268   -13284.268    297.08584    297.08584    67393.623    67393.623   -467.13362   -467.13362 
   24000   -13129.594   -13129.594   -13280.435   -13280.435    291.81277    291.81277    67352.369    67352.369     163.6588     163.6588 
Loop time of 385.642 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.123 hours/ns, 2.593 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 384.52     | 384.52     | 384.52     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16773    | 0.16773    | 0.16773    |   0.0 |  0.04
Output  | 0.00025251 | 0.00025251 | 0.00025251 |   0.0 |  0.00
Modify  | 0.83915    | 0.83915    | 0.83915    |   0.0 |  0.22
Other   |            | 0.1102     |            |       |  0.03

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:      282332.0 ave      282332 max      282332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282332
Ave neighs/atom = 70.583000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.956934594972, Press = 0.570987893493081
next a
jump SELF top
variable a loop 2000
run 1000
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.594   -13129.594   -13280.435   -13280.435    291.81277    291.81277    67352.369    67352.369     163.6588     163.6588 
   25000   -13133.552   -13133.552   -13286.577   -13286.577    296.03563    296.03563    67269.968    67269.968    751.15276    751.15276 
Loop time of 386.444 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.345 hours/ns, 2.588 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 385.32     | 385.32     | 385.32     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16854    | 0.16854    | 0.16854    |   0.0 |  0.04
Output  | 0.00017652 | 0.00017652 | 0.00017652 |   0.0 |  0.00
Modify  | 0.84175    | 0.84175    | 0.84175    |   0.0 |  0.22
Other   |            | 0.1087     |            |       |  0.03

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:      282456.0 ave      282456 max      282456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282456
Ave neighs/atom = 70.614000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.05084251793, Press = 0.616682196286681
next a
jump SELF top
variable a loop 2000
run 1000
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.552   -13133.552   -13286.577   -13286.577    296.03563    296.03563    67269.968    67269.968    751.15276    751.15276 
   26000   -13129.573   -13129.573   -13282.191   -13282.191    295.24879    295.24879    67196.202    67196.202    1863.0319    1863.0319 
Loop time of 384.74 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.872 hours/ns, 2.599 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.63     | 383.63     | 383.63     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16632    | 0.16632    | 0.16632    |   0.0 |  0.04
Output  | 0.00022029 | 0.00022029 | 0.00022029 |   0.0 |  0.00
Modify  | 0.83261    | 0.83261    | 0.83261    |   0.0 |  0.22
Other   |            | 0.1089     |            |       |  0.03

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:      283530.0 ave      283530 max      283530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283530
Ave neighs/atom = 70.882500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.033373969515, Press = -0.719488165483886
next a
jump SELF top
variable a loop 2000
run 1000
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.573   -13129.573   -13282.191   -13282.191    295.24879    295.24879    67196.202    67196.202    1863.0319    1863.0319 
   27000   -13135.128   -13135.128   -13283.518   -13283.518    287.07025    287.07025    67287.891    67287.891    608.12456    608.12456 
Loop time of 381.116 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.866 hours/ns, 2.624 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    | 380.03     | 380.03     | 380.03     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16646    | 0.16646    | 0.16646    |   0.0 |  0.04
Output  | 0.00023223 | 0.00023223 | 0.00023223 |   0.0 |  0.00
Modify  | 0.81639    | 0.81639    | 0.81639    |   0.0 |  0.21
Other   |            | 0.1079     |            |       |  0.03

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:      283948.0 ave      283948 max      283948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283948
Ave neighs/atom = 70.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.954914978035, Press = -1.69852766284853
next a
jump SELF top
variable a loop 2000
run 1000
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   -13135.128   -13135.128   -13283.518   -13283.518    287.07025    287.07025    67287.891    67287.891    608.12456    608.12456 
   28000   -13127.655   -13127.655   -13281.989   -13281.989    298.57051    298.57051    67383.077    67383.077   -233.45682   -233.45682 
Loop time of 386.346 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.318 hours/ns, 2.588 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    | 385.23     | 385.23     | 385.23     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16848    | 0.16848    | 0.16848    |   0.0 |  0.04
Output  | 0.00018225 | 0.00018225 | 0.00018225 |   0.0 |  0.00
Modify  | 0.83514    | 0.83514    | 0.83514    |   0.0 |  0.22
Other   |            | 0.109      |            |       |  0.03

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:      283038.0 ave      283038 max      283038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283038
Ave neighs/atom = 70.759500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.919291976814, Press = -1.14608218138864
next a
jump SELF top
variable a loop 2000
run 1000
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.655   -13127.655   -13281.989   -13281.989    298.57051    298.57051    67383.077    67383.077   -233.45682   -233.45682 
   29000   -13130.785   -13130.785    -13281.32    -13281.32    291.22024    291.22024    67401.197    67401.197   -446.32061   -446.32061 
Loop time of 386.569 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.380 hours/ns, 2.587 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    | 385.45     | 385.45     | 385.45     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16846    | 0.16846    | 0.16846    |   0.0 |  0.04
Output  | 0.00017968 | 0.00017968 | 0.00017968 |   0.0 |  0.00
Modify  | 0.83992    | 0.83992    | 0.83992    |   0.0 |  0.22
Other   |            | 0.1086     |            |       |  0.03

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 = 292.924193520467, Press = -1.04557475610523
next a
jump SELF top
variable a loop 2000
run 1000
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   -13130.785   -13130.785    -13281.32    -13281.32    291.22024    291.22024    67401.197    67401.197   -446.32061   -446.32061 
   30000    -13130.41    -13130.41   -13281.013   -13281.013    291.35283    291.35283    67445.557    67445.557   -929.25933   -929.25933 
Loop time of 362.678 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.744 hours/ns, 2.757 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    | 361.65     | 361.65     | 361.65     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1591     | 0.1591     | 0.1591     |   0.0 |  0.04
Output  | 0.00021586 | 0.00021586 | 0.00021586 |   0.0 |  0.00
Modify  | 0.76559    | 0.76559    | 0.76559    |   0.0 |  0.21
Other   |            | 0.1036     |            |       |  0.03

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:      281828.0 ave      281828 max      281828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281828
Ave neighs/atom = 70.457000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.915645048002, Press = -0.288836807641584
next a
jump SELF top
variable a loop 2000
run 1000
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    -13130.41    -13130.41   -13281.013   -13281.013    291.35283    291.35283    67445.557    67445.557   -929.25933   -929.25933 
   31000   -13131.446   -13131.446   -13280.557   -13280.557    288.46536    288.46536     67511.67     67511.67   -1673.6268   -1673.6268 
Loop time of 331.277 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 92.022 hours/ns, 3.019 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 330.37     | 330.37     | 330.37     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14533    | 0.14533    | 0.14533    |   0.0 |  0.04
Output  | 0.00018315 | 0.00018315 | 0.00018315 |   0.0 |  0.00
Modify  | 0.668      | 0.668      | 0.668      |   0.0 |  0.20
Other   |            | 0.09473    |            |       |  0.03

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:      281626.0 ave      281626 max      281626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281626
Ave neighs/atom = 70.406500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.941581469056, Press = 1.327707175952
next a
jump SELF top
variable a loop 2000
run 1000
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.446   -13131.446   -13280.557   -13280.557    288.46536    288.46536     67511.67     67511.67   -1673.6268   -1673.6268 
   32000   -13133.185   -13133.185   -13283.314   -13283.314    290.43584    290.43584    67353.665    67353.665     -36.9462     -36.9462 
Loop time of 364.405 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 363.38     | 363.38     | 363.38     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15595    | 0.15595    | 0.15595    |   0.0 |  0.04
Output  | 0.00017881 | 0.00017881 | 0.00017881 |   0.0 |  0.00
Modify  | 0.76235    | 0.76235    | 0.76235    |   0.0 |  0.21
Other   |            | 0.1023     |            |       |  0.03

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:      280844.0 ave      280844 max      280844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280844
Ave neighs/atom = 70.211000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.932698538662, Press = 1.07269007321979
next a
jump SELF top
variable a loop 2000
run 1000
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   -13133.185   -13133.185   -13283.314   -13283.314    290.43584    290.43584    67353.665    67353.665     -36.9462     -36.9462 
   33000   -13126.951   -13126.951   -13281.361   -13281.361    298.71615    298.71615    67344.464    67344.464    295.28564    295.28564 
Loop time of 356.915 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.242 ns/day, 99.143 hours/ns, 2.802 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 355.91     | 355.91     | 355.91     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15323    | 0.15323    | 0.15323    |   0.0 |  0.04
Output  | 0.00018395 | 0.00018395 | 0.00018395 |   0.0 |  0.00
Modify  | 0.74609    | 0.74609    | 0.74609    |   0.0 |  0.21
Other   |            | 0.1006     |            |       |  0.03

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:      282358.0 ave      282358 max      282358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282358
Ave neighs/atom = 70.589500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.93211658787, Press = 0.44954190111861
next a
jump SELF top
variable a loop 2000
run 1000
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   -13126.951   -13126.951   -13281.361   -13281.361    298.71615    298.71615    67344.464    67344.464    295.28564    295.28564 
   34000   -13131.762   -13131.762   -13283.816   -13283.816    294.15947    294.15947    67304.179    67304.179    483.28535    483.28535 
Loop time of 330.62 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.839 hours/ns, 3.025 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 329.72     | 329.72     | 329.72     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.146      | 0.146      | 0.146      |   0.0 |  0.04
Output  | 0.00022305 | 0.00022305 | 0.00022305 |   0.0 |  0.00
Modify  | 0.66293    | 0.66293    | 0.66293    |   0.0 |  0.20
Other   |            | 0.09394    |            |       |  0.03

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:      282500.0 ave      282500 max      282500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282500
Ave neighs/atom = 70.625000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.925697499388, Press = -0.113264453783891
next a
jump SELF top
variable a loop 2000
run 1000
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   -13131.762   -13131.762   -13283.816   -13283.816    294.15947    294.15947    67304.179    67304.179    483.28535    483.28535 
   35000   -13129.231   -13129.231   -13279.761   -13279.761    291.21231    291.21231    67308.343    67308.343    700.61762    700.61762 
Loop time of 359.632 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.240 ns/day, 99.898 hours/ns, 2.781 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 358.63     | 358.63     | 358.63     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15518    | 0.15518    | 0.15518    |   0.0 |  0.04
Output  | 0.00018394 | 0.00018394 | 0.00018394 |   0.0 |  0.00
Modify  | 0.74949    | 0.74949    | 0.74949    |   0.0 |  0.21
Other   |            | 0.1012     |            |       |  0.03

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:      282762.0 ave      282762 max      282762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282762
Ave neighs/atom = 70.690500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.924805978392, Press = -0.678383985306639
next a
jump SELF top
variable a loop 2000
run 1000
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   -13129.231   -13129.231   -13279.761   -13279.761    291.21231    291.21231    67308.343    67308.343    700.61762    700.61762 
   36000   -13132.501   -13132.501   -13285.303   -13285.303     295.6054     295.6054    67313.409    67313.409    311.61534    311.61534 
Loop time of 385.051 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.959 hours/ns, 2.597 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    | 383.96     | 383.96     | 383.96     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16341    | 0.16341    | 0.16341    |   0.0 |  0.04
Output  | 0.0001804  | 0.0001804  | 0.0001804  |   0.0 |  0.00
Modify  | 0.82569    | 0.82569    | 0.82569    |   0.0 |  0.21
Other   |            | 0.1065     |            |       |  0.03

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:      282662.0 ave      282662 max      282662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282662
Ave neighs/atom = 70.665500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.956431369291, Press = -1.42873178527996
next a
jump SELF top
variable a loop 2000
run 1000
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   -13132.501   -13132.501   -13285.303   -13285.303     295.6054     295.6054    67313.409    67313.409    311.61534    311.61534 
   37000   -13125.502   -13125.502   -13278.728   -13278.728    296.42617    296.42617    67429.878    67429.878   -518.08969   -518.08969 
Loop time of 371.654 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.237 hours/ns, 2.691 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.6      | 370.6      | 370.6      |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15914    | 0.15914    | 0.15914    |   0.0 |  0.04
Output  | 0.00018197 | 0.00018197 | 0.00018197 |   0.0 |  0.00
Modify  | 0.79107    | 0.79107    | 0.79107    |   0.0 |  0.21
Other   |            | 0.1045     |            |       |  0.03

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:      282962.0 ave      282962 max      282962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282962
Ave neighs/atom = 70.740500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.004220145258, Press = -1.59585759737793
next a
jump SELF top
variable a loop 2000
run 1000
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   -13125.502   -13125.502   -13278.728   -13278.728    296.42617    296.42617    67429.878    67429.878   -518.08969   -518.08969 
   38000   -13132.519   -13132.519   -13283.324   -13283.324    291.74139    291.74139    67403.218    67403.218   -600.05043   -600.05043 
Loop time of 369.107 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.530 hours/ns, 2.709 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.06     | 368.06     | 368.06     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15818    | 0.15818    | 0.15818    |   0.0 |  0.04
Output  | 0.00027883 | 0.00027883 | 0.00027883 |   0.0 |  0.00
Modify  | 0.782      | 0.782      | 0.782      |   0.0 |  0.21
Other   |            | 0.1036     |            |       |  0.03

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 = 293.035272445879, Press = -0.571037386569842
next a
jump SELF top
variable a loop 2000
run 1000
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   -13132.519   -13132.519   -13283.324   -13283.324    291.74139    291.74139    67403.218    67403.218   -600.05043   -600.05043 
   39000   -13126.446   -13126.446   -13277.562   -13277.562    292.34387    292.34387     67400.04     67400.04   -125.53151   -125.53151 
Loop time of 365.813 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.615 hours/ns, 2.734 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 364.79     | 364.79     | 364.79     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15521    | 0.15521    | 0.15521    |   0.0 |  0.04
Output  | 0.00018372 | 0.00018372 | 0.00018372 |   0.0 |  0.00
Modify  | 0.76461    | 0.76461    | 0.76461    |   0.0 |  0.21
Other   |            | 0.1029     |            |       |  0.03

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:      282046.0 ave      282046 max      282046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282046
Ave neighs/atom = 70.511500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.070406380934, Press = -0.309183346225676
next a
jump SELF top
variable a loop 2000
run 1000
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   -13126.446   -13126.446   -13277.562   -13277.562    292.34387    292.34387     67400.04     67400.04   -125.53151   -125.53151 
   40000   -13129.816   -13129.816   -13282.934   -13282.934    296.21677    296.21677    67370.969    67370.969   -109.99407   -109.99407 
Loop time of 332.782 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.439 hours/ns, 3.005 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 331.86     | 331.86     | 331.86     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14715    | 0.14715    | 0.14715    |   0.0 |  0.04
Output  | 0.00023507 | 0.00023507 | 0.00023507 |   0.0 |  0.00
Modify  | 0.67567    | 0.67567    | 0.67567    |   0.0 |  0.20
Other   |            | 0.09449    |            |       |  0.03

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:      281558.0 ave      281558 max      281558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281558
Ave neighs/atom = 70.389500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.04524204612, Press = 0.244756764445314
next a
jump SELF top
variable a loop 2000
run 1000
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   -13129.816   -13129.816   -13282.934   -13282.934    296.21677    296.21677    67370.969    67370.969   -109.99407   -109.99407 
   41000   -13135.847   -13135.847   -13286.665   -13286.665    291.76881    291.76881    67309.692    67309.692    226.44118    226.44118 
Loop time of 354.04 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.244 ns/day, 98.344 hours/ns, 2.825 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 353.04     | 353.04     | 353.04     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15432    | 0.15432    | 0.15432    |   0.0 |  0.04
Output  | 0.00045077 | 0.00045077 | 0.00045077 |   0.0 |  0.00
Modify  | 0.74402    | 0.74402    | 0.74402    |   0.0 |  0.21
Other   |            | 0.09988    |            |       |  0.03

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:      282450.0 ave      282450 max      282450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282450
Ave neighs/atom = 70.612500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.025347002183, Press = 0.297540392316527
next a
jump SELF top
variable a loop 2000
run 1000
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   -13135.847   -13135.847   -13286.665   -13286.665    291.76881    291.76881    67309.692    67309.692    226.44118    226.44118 
   42000   -13129.826   -13129.826   -13283.124   -13283.124    296.56541    296.56541    67258.912    67258.912    1073.0191    1073.0191 
Loop time of 332.688 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.413 hours/ns, 3.006 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    | 331.78     | 331.78     | 331.78     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14515    | 0.14515    | 0.14515    |   0.0 |  0.04
Output  | 0.00023583 | 0.00023583 | 0.00023583 |   0.0 |  0.00
Modify  | 0.67204    | 0.67204    | 0.67204    |   0.0 |  0.20
Other   |            | 0.09524    |            |       |  0.03

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:      282726.0 ave      282726 max      282726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282726
Ave neighs/atom = 70.681500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.012710920173, Press = 0.22133724649144
next a
jump SELF top
variable a loop 2000
run 1000
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 
   42000   -13129.826   -13129.826   -13283.124   -13283.124    296.56541    296.56541    67258.912    67258.912    1073.0191    1073.0191 
   43000   -13138.174   -13138.174   -13285.657   -13285.657    285.31524    285.31524    67226.499    67226.499    1190.6025    1190.6025 
Loop time of 386.209 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.280 hours/ns, 2.589 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    | 385.12     | 385.12     | 385.12     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16401    | 0.16401    | 0.16401    |   0.0 |  0.04
Output  | 0.00017822 | 0.00017822 | 0.00017822 |   0.0 |  0.00
Modify  | 0.82044    | 0.82044    | 0.82044    |   0.0 |  0.21
Other   |            | 0.1058     |            |       |  0.03

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:      283346.0 ave      283346 max      283346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283346
Ave neighs/atom = 70.836500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.97739183811, Press = -0.780621114719207
next a
jump SELF top
variable a loop 2000
run 1000
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 
   43000   -13138.174   -13138.174   -13285.657   -13285.657    285.31524    285.31524    67226.499    67226.499    1190.6025    1190.6025 
   44000   -13130.174   -13130.174   -13283.117   -13283.117    295.87855    295.87855    67355.158    67355.158   -6.9020674   -6.9020674 
Loop time of 343.275 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.354 hours/ns, 2.913 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 342.32     | 342.32     | 342.32     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14896    | 0.14896    | 0.14896    |   0.0 |  0.04
Output  | 0.00027461 | 0.00027461 | 0.00027461 |   0.0 |  0.00
Modify  | 0.7051     | 0.7051     | 0.7051     |   0.0 |  0.21
Other   |            | 0.0986     |            |       |  0.03

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:      283474.0 ave      283474 max      283474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283474
Ave neighs/atom = 70.868500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.934025187193, Press = -0.639411749807102
next a
jump SELF top
variable a loop 2000
run 1000
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 
   44000   -13130.174   -13130.174   -13283.117   -13283.117    295.87855    295.87855    67355.158    67355.158   -6.9020674   -6.9020674 
   45000   -13135.903   -13135.903   -13285.541   -13285.541    289.48463    289.48463    67344.573    67344.573   -116.54352   -116.54352 
Loop time of 387.995 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.777 hours/ns, 2.577 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    | 386.89     | 386.89     | 386.89     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16555    | 0.16555    | 0.16555    |   0.0 |  0.04
Output  | 0.0002338  | 0.0002338  | 0.0002338  |   0.0 |  0.00
Modify  | 0.83005    | 0.83005    | 0.83005    |   0.0 |  0.21
Other   |            | 0.1071     |            |       |  0.03

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:      282386.0 ave      282386 max      282386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282386
Ave neighs/atom = 70.596500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.916419004833, Press = -0.405315303240614
next a
jump SELF top
variable a loop 2000
run 1000
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 
   45000   -13135.903   -13135.903   -13285.541   -13285.541    289.48463    289.48463    67344.573    67344.573   -116.54352   -116.54352 
   46000   -13132.977   -13132.977   -13283.692   -13283.692    291.56918    291.56918    67371.432    67371.432   -278.81594   -278.81594 
Loop time of 382.97 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.381 hours/ns, 2.611 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    | 381.89     | 381.89     | 381.89     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16271    | 0.16271    | 0.16271    |   0.0 |  0.04
Output  | 0.00017914 | 0.00017914 | 0.00017914 |   0.0 |  0.00
Modify  | 0.81505    | 0.81505    | 0.81505    |   0.0 |  0.21
Other   |            | 0.1071     |            |       |  0.03

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:      282432.0 ave      282432 max      282432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282432
Ave neighs/atom = 70.608000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.901973774788, Press = -0.227401861376063
next a
jump SELF top
variable a loop 2000
run 1000
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 
   46000   -13132.977   -13132.977   -13283.692   -13283.692    291.56918    291.56918    67371.432    67371.432   -278.81594   -278.81594 
   47000    -13130.53    -13130.53   -13280.424   -13280.424    289.98021    289.98021    67425.233    67425.233   -641.58584   -641.58584 
Loop time of 341.003 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.723 hours/ns, 2.933 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    | 340.06     | 340.06     | 340.06     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1476     | 0.1476     | 0.1476     |   0.0 |  0.04
Output  | 0.00017938 | 0.00017938 | 0.00017938 |   0.0 |  0.00
Modify  | 0.69865    | 0.69865    | 0.69865    |   0.0 |  0.20
Other   |            | 0.09976    |            |       |  0.03

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.940687524458, Press = -0.143535812867192
next a
jump SELF top
variable a loop 2000
run 1000
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 
   47000    -13130.53    -13130.53   -13280.424   -13280.424    289.98021    289.98021    67425.233    67425.233   -641.58584   -641.58584 
   48000   -13127.564   -13127.564   -13280.493   -13280.493    295.85198    295.85198    67443.222    67443.222   -829.58175   -829.58175 
Loop time of 374.49 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 104.025 hours/ns, 2.670 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    | 373.43     | 373.43     | 373.43     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1593     | 0.1593     | 0.1593     |   0.0 |  0.04
Output  | 0.00023669 | 0.00023669 | 0.00023669 |   0.0 |  0.00
Modify  | 0.79971    | 0.79971    | 0.79971    |   0.0 |  0.21
Other   |            | 0.1053     |            |       |  0.03

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:      281448.0 ave      281448 max      281448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281448
Ave neighs/atom = 70.362000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.972084974892, Press = 0.359006728784176
next a
jump SELF top
variable a loop 2000
run 1000
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 
   48000   -13127.564   -13127.564   -13280.493   -13280.493    295.85198    295.85198    67443.222    67443.222   -829.58175   -829.58175 
   49000    -13131.02    -13131.02   -13280.856   -13280.856    289.86882    289.86882    67345.693    67345.693    197.41675    197.41675 
Loop time of 379.489 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.414 hours/ns, 2.635 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 378.41     | 378.41     | 378.41     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16261    | 0.16261    | 0.16261    |   0.0 |  0.04
Output  | 0.00017791 | 0.00017791 | 0.00017791 |   0.0 |  0.00
Modify  | 0.81135    | 0.81135    | 0.81135    |   0.0 |  0.21
Other   |            | 0.1057     |            |       |  0.03

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:      281480.0 ave      281480 max      281480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281480
Ave neighs/atom = 70.370000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.011400803473, Press = 0.767888460415261
next a
jump SELF top
variable a loop 2000
run 1000
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 
   49000    -13131.02    -13131.02   -13280.856   -13280.856    289.86882    289.86882    67345.693    67345.693    197.41675    197.41675 
   50000   -13128.407   -13128.407   -13280.178   -13280.178    293.61228    293.61228    67281.721    67281.721    967.23362    967.23362 
Loop time of 384.428 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.786 hours/ns, 2.601 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.32     | 383.32     | 383.32     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16597    | 0.16597    | 0.16597    |   0.0 |  0.04
Output  | 0.0001793  | 0.0001793  | 0.0001793  |   0.0 |  0.00
Modify  | 0.83077    | 0.83077    | 0.83077    |   0.0 |  0.22
Other   |            | 0.1078     |            |       |  0.03

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 = 293.01676297187, Press = 0.36123406043208
next a
jump SELF top
variable a loop 2000
run 1000
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 
   50000   -13128.407   -13128.407   -13280.178   -13280.178    293.61228    293.61228    67281.721    67281.721    967.23362    967.23362 
   51000   -13129.721   -13129.721    -13279.99    -13279.99    290.70608    290.70608     67294.53     67294.53    838.11148    838.11148 
Loop time of 376.341 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.539 hours/ns, 2.657 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    | 375.26     | 375.26     | 375.26     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16415    | 0.16415    | 0.16415    |   0.0 |  0.04
Output  | 0.00024161 | 0.00024161 | 0.00024161 |   0.0 |  0.00
Modify  | 0.81121    | 0.81121    | 0.81121    |   0.0 |  0.22
Other   |            | 0.1064     |            |       |  0.03

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:      282618.0 ave      282618 max      282618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282618
Ave neighs/atom = 70.654500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.072816540954, Press = -0.29317442787254
next a
jump SELF top
variable a loop 2000
run 1000
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 
   51000   -13129.721   -13129.721    -13279.99    -13279.99    290.70608    290.70608     67294.53     67294.53    838.11148    838.11148 
   52000   -13133.765   -13133.765    -13283.15    -13283.15    288.99508    288.99508    67346.845    67346.845    7.4713277    7.4713277 
Loop time of 359.573 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.240 ns/day, 99.881 hours/ns, 2.781 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    | 358.56     | 358.56     | 358.56     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15525    | 0.15525    | 0.15525    |   0.0 |  0.04
Output  | 0.00017747 | 0.00017747 | 0.00017747 |   0.0 |  0.00
Modify  | 0.75222    | 0.75222    | 0.75222    |   0.0 |  0.21
Other   |            | 0.102      |            |       |  0.03

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:      282700.0 ave      282700 max      282700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282700
Ave neighs/atom = 70.675000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.078131593202, Press = -0.389921927896569
next a
jump SELF top
variable a loop 2000
run 1000
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 
   52000   -13133.765   -13133.765    -13283.15    -13283.15    288.99508    288.99508    67346.845    67346.845    7.4713277    7.4713277 
   53000   -13128.704   -13128.704   -13280.386   -13280.386    293.43934    293.43934    67403.838    67403.838   -447.54845   -447.54845 
Loop time of 379.341 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.373 hours/ns, 2.636 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    | 378.25     | 378.25     | 378.25     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1643     | 0.1643     | 0.1643     |   0.0 |  0.04
Output  | 0.00017793 | 0.00017793 | 0.00017793 |   0.0 |  0.00
Modify  | 0.8209     | 0.8209     | 0.8209     |   0.0 |  0.22
Other   |            | 0.1075     |            |       |  0.03

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:      282344.0 ave      282344 max      282344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282344
Ave neighs/atom = 70.586000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.076980596827, Press = -0.241395730316112
next a
jump SELF top
variable a loop 2000
run 1000
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 
   53000   -13128.704   -13128.704   -13280.386   -13280.386    293.43934    293.43934    67403.838    67403.838   -447.54845   -447.54845 
   54000   -13135.348   -13135.348   -13281.287   -13281.287    282.32941    282.32941    67369.773    67369.773   -171.25568   -171.25568 
Loop time of 372.221 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.395 hours/ns, 2.687 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    | 371.15     | 371.15     | 371.15     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16278    | 0.16278    | 0.16278    |   0.0 |  0.04
Output  | 0.00022207 | 0.00022207 | 0.00022207 |   0.0 |  0.00
Modify  | 0.79918    | 0.79918    | 0.79918    |   0.0 |  0.21
Other   |            | 0.1052     |            |       |  0.03

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:      281442.0 ave      281442 max      281442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281442
Ave neighs/atom = 70.360500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.078743984126, Press = 0.378442953203937
next a
jump SELF top
variable a loop 2000
run 1000
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 
   54000   -13135.348   -13135.348   -13281.287   -13281.287    282.32941    282.32941    67369.773    67369.773   -171.25568   -171.25568 
   55000   -13128.743   -13128.743   -13281.822   -13281.822    296.14305    296.14305    67285.663    67285.663    918.58856    918.58856 
Loop time of 384.221 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.728 hours/ns, 2.603 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    | 383.12     | 383.12     | 383.12     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16549    | 0.16549    | 0.16549    |   0.0 |  0.04
Output  | 0.00023309 | 0.00023309 | 0.00023309 |   0.0 |  0.00
Modify  | 0.82822    | 0.82822    | 0.82822    |   0.0 |  0.22
Other   |            | 0.1065     |            |       |  0.03

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:      282072.0 ave      282072 max      282072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282072
Ave neighs/atom = 70.518000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.041668505915, Press = 0.700843799629844
next a
jump SELF top
variable a loop 2000
run 1000
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 
   55000   -13128.743   -13128.743   -13281.822   -13281.822    296.14305    296.14305    67285.663    67285.663    918.58856    918.58856 
   56000   -13134.705   -13134.705   -13283.116   -13283.116    287.11224    287.11224    67227.097    67227.097    1398.8933    1398.8933 
Loop time of 381.501 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 105.973 hours/ns, 2.621 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    | 380.4      | 380.4      | 380.4      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16666    | 0.16666    | 0.16666    |   0.0 |  0.04
Output  | 0.00017933 | 0.00017933 | 0.00017933 |   0.0 |  0.00
Modify  | 0.82458    | 0.82458    | 0.82458    |   0.0 |  0.22
Other   |            | 0.1055     |            |       |  0.03

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:      283052.0 ave      283052 max      283052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283052
Ave neighs/atom = 70.763000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
67359.7583366955

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0