# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 4.044650763273239*${_u_distance}
variable latticeconst_converted equal 4.044650763273239*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04465076327324
Lattice spacing in x,y,z = 4.0446508 4.0446508 4.0446508
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (40.446508 40.446508 40.446508)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (40.446508 40.446508 40.446508)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Al

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

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


mass          1 ${mass_converted}
mass          1 26.981538

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

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

Performance: 0.681 ns/day, 35.252 hours/ns, 7.880 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    | 126.52     | 126.52     | 126.52     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050575   | 0.050575   | 0.050575   |   0.0 |  0.04
Output  | 0.00026713 | 0.00026713 | 0.00026713 |   0.0 |  0.00
Modify  | 0.2895     | 0.2895     | 0.2895     |   0.0 |  0.23
Other   |            | 0.04725    |            |       |  0.04

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

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

Performance: 0.672 ns/day, 35.688 hours/ns, 7.783 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.09     | 128.09     | 128.09     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049747   | 0.049747   | 0.049747   |   0.0 |  0.04
Output  | 0.00013255 | 0.00013255 | 0.00013255 |   0.0 |  0.00
Modify  | 0.29276    | 0.29276    | 0.29276    |   0.0 |  0.23
Other   |            | 0.04877    |            |       |  0.04

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

Total # of neighbors = 284198
Ave neighs/atom = 71.049500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -13158.022   -13158.022   -13294.667   -13294.667    264.34952    264.34952    67217.314    67217.314    548.24427    548.24427 
    3000   -13148.555   -13148.555   -13286.704   -13286.704     267.2576     267.2576    67264.926    67264.926    488.09485    488.09485 
Loop time of 128.699 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.671 ns/day, 35.750 hours/ns, 7.770 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.31     | 128.31     | 128.31     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049535   | 0.049535   | 0.049535   |   0.0 |  0.04
Output  | 0.0002463  | 0.0002463  | 0.0002463  |   0.0 |  0.00
Modify  | 0.29286    | 0.29286    | 0.29286    |   0.0 |  0.23
Other   |            | 0.04833    |            |       |  0.04

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

Total # of neighbors = 284358
Ave neighs/atom = 71.089500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -13148.555   -13148.555   -13286.704   -13286.704     267.2576     267.2576    67264.926    67264.926    488.09485    488.09485 
    4000   -13155.153   -13155.153   -13294.877   -13294.877    270.30611    270.30611    67251.439    67251.439    129.44704    129.44704 
Loop time of 127.284 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.679 ns/day, 35.357 hours/ns, 7.856 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.9      | 126.9      | 126.9      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049331   | 0.049331   | 0.049331   |   0.0 |  0.04
Output  | 0.00013738 | 0.00013738 | 0.00013738 |   0.0 |  0.00
Modify  | 0.28853    | 0.28853    | 0.28853    |   0.0 |  0.23
Other   |            | 0.04719    |            |       |  0.04

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

Total # of neighbors = 283000
Ave neighs/atom = 70.750000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -13155.153   -13155.153   -13294.877   -13294.877    270.30611    270.30611    67251.439    67251.439    129.44704    129.44704 
    5000   -13152.484   -13152.484   -13293.204   -13293.204    272.23304    272.23304    67249.092    67249.092    312.25743    312.25743 
Loop time of 130.802 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.661 ns/day, 36.334 hours/ns, 7.645 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.4      | 130.4      | 130.4      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050586   | 0.050586   | 0.050586   |   0.0 |  0.04
Output  | 0.00010648 | 0.00010648 | 0.00010648 |   0.0 |  0.00
Modify  | 0.30116    | 0.30116    | 0.30116    |   0.0 |  0.23
Other   |            | 0.0504     |            |       |  0.04

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

Total # of neighbors = 284036
Ave neighs/atom = 71.009000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.979038742259, Press = 251.214941747292
next a
jump SELF top
variable a loop 2000
run 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   -13152.484   -13152.484   -13293.204   -13293.204    272.23304    272.23304    67249.092    67249.092    312.25743    312.25743 
    6000   -13150.848   -13150.848   -13290.929   -13290.929    270.99692    270.99692    67244.098    67244.098    526.25994    526.25994 
Loop time of 128.403 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.673 ns/day, 35.668 hours/ns, 7.788 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128        | 128        | 128        |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049542   | 0.049542   | 0.049542   |   0.0 |  0.04
Output  | 0.00010165 | 0.00010165 | 0.00010165 |   0.0 |  0.00
Modify  | 0.30357    | 0.30357    | 0.30357    |   0.0 |  0.24
Other   |            | 0.04932    |            |       |  0.04

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

Total # of neighbors = 283864
Ave neighs/atom = 70.966000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.681771077992, Press = 41.1029824238852
next a
jump SELF top
variable a loop 2000
run 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   -13150.848   -13150.848   -13290.929   -13290.929    270.99692    270.99692    67244.098    67244.098    526.25994    526.25994 
    7000   -13154.266   -13154.266   -13293.225   -13293.225    268.82541    268.82541    67252.681    67252.681    169.47177    169.47177 
Loop time of 127.821 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.506 hours/ns, 7.823 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.42     | 127.42     | 127.42     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050146   | 0.050146   | 0.050146   |   0.0 |  0.04
Output  | 0.00011051 | 0.00011051 | 0.00011051 |   0.0 |  0.00
Modify  | 0.30296    | 0.30296    | 0.30296    |   0.0 |  0.24
Other   |            | 0.04813    |            |       |  0.04

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

Total # of neighbors = 283854
Ave neighs/atom = 70.963500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.171027959684, Press = 28.7074532696939
next a
jump SELF top
variable a loop 2000
run 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   -13154.266   -13154.266   -13293.225   -13293.225    268.82541    268.82541    67252.681    67252.681    169.47177    169.47177 
    8000   -13151.419   -13151.419   -13294.205   -13294.205    276.22776    276.22776    67297.324    67297.324   -306.63877   -306.63877 
Loop time of 137.899 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.627 ns/day, 38.305 hours/ns, 7.252 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.46     | 137.46     | 137.46     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057668   | 0.057668   | 0.057668   |   0.0 |  0.04
Output  | 0.00010635 | 0.00010635 | 0.00010635 |   0.0 |  0.00
Modify  | 0.33416    | 0.33416    | 0.33416    |   0.0 |  0.24
Other   |            | 0.05083    |            |       |  0.04

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

Total # of neighbors = 283554
Ave neighs/atom = 70.888500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.959350251593, Press = 13.6467416232699
next a
jump SELF top
variable a loop 2000
run 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   -13151.419   -13151.419   -13294.205   -13294.205    276.22776    276.22776    67297.324    67297.324   -306.63877   -306.63877 
    9000   -13151.999   -13151.999   -13294.851   -13294.851    276.35697    276.35697    67292.031    67292.031    -260.2849    -260.2849 
Loop time of 143.659 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.601 ns/day, 39.905 hours/ns, 6.961 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    | 143.18     | 143.18     | 143.18     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063303   | 0.063303   | 0.063303   |   0.0 |  0.04
Output  | 0.00012114 | 0.00012114 | 0.00012114 |   0.0 |  0.00
Modify  | 0.35769    | 0.35769    | 0.35769    |   0.0 |  0.25
Other   |            | 0.05374    |            |       |  0.04

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

Total # of neighbors = 283814
Ave neighs/atom = 70.953500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.857123446014, Press = 7.58949512413874
next a
jump SELF top
variable a loop 2000
run 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   -13151.999   -13151.999   -13294.851   -13294.851    276.35697    276.35697    67292.031    67292.031    -260.2849    -260.2849 
   10000   -13156.958   -13156.958    -13295.09    -13295.09    267.22667    267.22667    67262.272    67262.272   -21.706269   -21.706269 
Loop time of 141.717 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.610 ns/day, 39.366 hours/ns, 7.056 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    | 141.27     | 141.27     | 141.27     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055934   | 0.055934   | 0.055934   |   0.0 |  0.04
Output  | 0.0001265  | 0.0001265  | 0.0001265  |   0.0 |  0.00
Modify  | 0.34271    | 0.34271    | 0.34271    |   0.0 |  0.24
Other   |            | 0.05193    |            |       |  0.04

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

Total # of neighbors = 283788
Ave neighs/atom = 70.947000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.874009522496, Press = 2.23787795795793
next a
jump SELF top
variable a loop 2000
run 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   -13156.958   -13156.958    -13295.09    -13295.09    267.22667    267.22667    67262.272    67262.272   -21.706269   -21.706269 
   11000   -13156.054   -13156.054   -13296.002   -13296.002    270.73908    270.73908    67271.302    67271.302   -219.37299   -219.37299 
Loop time of 140.64 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.614 ns/day, 39.067 hours/ns, 7.110 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.19     | 140.19     | 140.19     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058034   | 0.058034   | 0.058034   |   0.0 |  0.04
Output  | 0.00011987 | 0.00011987 | 0.00011987 |   0.0 |  0.00
Modify  | 0.34164    | 0.34164    | 0.34164    |   0.0 |  0.24
Other   |            | 0.05149    |            |       |  0.04

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

Total # of neighbors = 283888
Ave neighs/atom = 70.972000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.776550053376, Press = 1.4521546119427
next a
jump SELF top
variable a loop 2000
run 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   -13156.054   -13156.054   -13296.002   -13296.002    270.73908    270.73908    67271.302    67271.302   -219.37299   -219.37299 
   12000   -13151.121   -13151.121   -13292.622   -13292.622     273.7426     273.7426    67323.261    67323.261   -463.74219   -463.74219 
Loop time of 142.868 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.605 ns/day, 39.686 hours/ns, 6.999 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.4      | 142.4      | 142.4      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059372   | 0.059372   | 0.059372   |   0.0 |  0.04
Output  | 0.0001136  | 0.0001136  | 0.0001136  |   0.0 |  0.00
Modify  | 0.35485    | 0.35485    | 0.35485    |   0.0 |  0.25
Other   |            | 0.05753    |            |       |  0.04

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

Total # of neighbors = 283870
Ave neighs/atom = 70.967500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.814248436367, Press = -0.13584349718969
next a
jump SELF top
variable a loop 2000
run 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   -13151.121   -13151.121   -13292.622   -13292.622     273.7426     273.7426    67323.261    67323.261   -463.74219   -463.74219 
   13000   -13157.322   -13157.322   -13296.816   -13296.816    269.86073    269.86073    67296.851    67296.851   -537.67722   -537.67722 
Loop time of 137.638 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.2      | 137.2      | 137.2      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056547   | 0.056547   | 0.056547   |   0.0 |  0.04
Output  | 0.00011984 | 0.00011984 | 0.00011984 |   0.0 |  0.00
Modify  | 0.33423    | 0.33423    | 0.33423    |   0.0 |  0.24
Other   |            | 0.05129    |            |       |  0.04

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

Total # of neighbors = 283396
Ave neighs/atom = 70.849000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.671444611633, Press = -1.03962480446437
next a
jump SELF top
variable a loop 2000
run 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   -13157.322   -13157.322   -13296.816   -13296.816    269.86073    269.86073    67296.851    67296.851   -537.67722   -537.67722 
   14000    -13153.13    -13153.13   -13293.482   -13293.482    271.52121    271.52121    67300.352    67300.352   -353.05275   -353.05275 
Loop time of 138.698 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.25     | 138.25     | 138.25     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059449   | 0.059449   | 0.059449   |   0.0 |  0.04
Output  | 0.00011756 | 0.00011756 | 0.00011756 |   0.0 |  0.00
Modify  | 0.34084    | 0.34084    | 0.34084    |   0.0 |  0.25
Other   |            | 0.052      |            |       |  0.04

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

Total # of neighbors = 283848
Ave neighs/atom = 70.962000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.686497533306, Press = -2.73419034628403
next a
jump SELF top
variable a loop 2000
run 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    -13153.13    -13153.13   -13293.482   -13293.482    271.52121    271.52121    67300.352    67300.352   -353.05275   -353.05275 
   15000   -13150.424   -13150.424   -13291.365   -13291.365    272.66144    272.66144    67280.649    67280.649    27.835759    27.835759 
Loop time of 138.16 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.625 ns/day, 38.378 hours/ns, 7.238 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    | 137.71     | 137.71     | 137.71     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05738    | 0.05738    | 0.05738    |   0.0 |  0.04
Output  | 0.00013665 | 0.00013665 | 0.00013665 |   0.0 |  0.00
Modify  | 0.33646    | 0.33646    | 0.33646    |   0.0 |  0.24
Other   |            | 0.05144    |            |       |  0.04

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

Total # of neighbors = 283462
Ave neighs/atom = 70.865500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.674760702507, Press = -1.96943842000921
next a
jump SELF top
variable a loop 2000
run 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   -13150.424   -13150.424   -13291.365   -13291.365    272.66144    272.66144    67280.649    67280.649    27.835759    27.835759 
   16000   -13152.074   -13152.074   -13292.312   -13292.312     271.2992     271.2992    67270.297    67270.297    86.010126    86.010126 
Loop time of 138.921 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.622 ns/day, 38.589 hours/ns, 7.198 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    | 138.47     | 138.47     | 138.47     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056525   | 0.056525   | 0.056525   |   0.0 |  0.04
Output  | 0.00012213 | 0.00012213 | 0.00012213 |   0.0 |  0.00
Modify  | 0.33799    | 0.33799    | 0.33799    |   0.0 |  0.24
Other   |            | 0.05208    |            |       |  0.04

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

Total # of neighbors = 283442
Ave neighs/atom = 70.860500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.783235647718, Press = -0.234193937940502
next a
jump SELF top
variable a loop 2000
run 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   -13152.074   -13152.074   -13292.312   -13292.312     271.2992     271.2992    67270.297    67270.297    86.010126    86.010126 
   17000   -13160.907   -13160.907   -13298.495   -13298.495    266.17329    266.17329    67221.982    67221.982    191.19441    191.19441 
Loop time of 139.549 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.1      | 139.1      | 139.1      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058833   | 0.058833   | 0.058833   |   0.0 |  0.04
Output  | 0.00011342 | 0.00011342 | 0.00011342 |   0.0 |  0.00
Modify  | 0.34099    | 0.34099    | 0.34099    |   0.0 |  0.24
Other   |            | 0.05149    |            |       |  0.04

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

Total # of neighbors = 283560
Ave neighs/atom = 70.890000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.729653068115, Press = -0.245119920970751
next a
jump SELF top
variable a loop 2000
run 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   -13160.907   -13160.907   -13298.495   -13298.495    266.17329    266.17329    67221.982    67221.982    191.19441    191.19441 
   18000   -13151.315   -13151.315   -13293.506   -13293.506    275.07811    275.07811    67240.085    67240.085    439.24239    439.24239 
Loop time of 139.172 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.621 ns/day, 38.659 hours/ns, 7.185 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.73     | 138.73     | 138.73     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055882   | 0.055882   | 0.055882   |   0.0 |  0.04
Output  | 0.00010144 | 0.00010144 | 0.00010144 |   0.0 |  0.00
Modify  | 0.33566    | 0.33566    | 0.33566    |   0.0 |  0.24
Other   |            | 0.05087    |            |       |  0.04

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

Total # of neighbors = 284534
Ave neighs/atom = 71.133500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.630087472826, Press = -0.648890295193552
next a
jump SELF top
variable a loop 2000
run 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   -13151.315   -13151.315   -13293.506   -13293.506    275.07811    275.07811    67240.085    67240.085    439.24239    439.24239 
   19000   -13153.673   -13153.673   -13293.152   -13293.152    269.83214    269.83214    67193.283    67193.283    981.11814    981.11814 
Loop time of 140.387 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.615 ns/day, 38.996 hours/ns, 7.123 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.93     | 139.93     | 139.93     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05648    | 0.05648    | 0.05648    |   0.0 |  0.04
Output  | 0.00010797 | 0.00010797 | 0.00010797 |   0.0 |  0.00
Modify  | 0.34345    | 0.34345    | 0.34345    |   0.0 |  0.24
Other   |            | 0.05463    |            |       |  0.04

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

Total # of neighbors = 284138
Ave neighs/atom = 71.034500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.670901814581, Press = -0.35880983127792
next a
jump SELF top
variable a loop 2000
run 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   -13153.673   -13153.673   -13293.152   -13293.152    269.83214    269.83214    67193.283    67193.283    981.11814    981.11814 
   20000    -13148.85    -13148.85   -13288.566   -13288.566    270.29019    270.29019    67179.976    67179.976     1420.035     1420.035 
Loop time of 137.088 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.630 ns/day, 38.080 hours/ns, 7.295 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.65     | 136.65     | 136.65     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054927   | 0.054927   | 0.054927   |   0.0 |  0.04
Output  | 0.00011061 | 0.00011061 | 0.00011061 |   0.0 |  0.00
Modify  | 0.33014    | 0.33014    | 0.33014    |   0.0 |  0.24
Other   |            | 0.05072    |            |       |  0.04

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

Total # of neighbors = 284348
Ave neighs/atom = 71.087000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.68650657827, Press = 0.439698492075115
next a
jump SELF top
variable a loop 2000
run 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    -13148.85    -13148.85   -13288.566   -13288.566    270.29019    270.29019    67179.976    67179.976     1420.035     1420.035 
   21000   -13153.907   -13153.907   -13294.485   -13294.485     271.9571     271.9571    67154.276    67154.276    1285.5785    1285.5785 
Loop time of 137.645 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.628 ns/day, 38.235 hours/ns, 7.265 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.21     | 137.21     | 137.21     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056699   | 0.056699   | 0.056699   |   0.0 |  0.04
Output  | 0.00011338 | 0.00011338 | 0.00011338 |   0.0 |  0.00
Modify  | 0.33129    | 0.33129    | 0.33129    |   0.0 |  0.24
Other   |            | 0.05011    |            |       |  0.04

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

Total # of neighbors = 284210
Ave neighs/atom = 71.052500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.767099488383, Press = 1.23750915164971
next a
jump SELF top
variable a loop 2000
run 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   -13153.907   -13153.907   -13294.485   -13294.485     271.9571     271.9571    67154.276    67154.276    1285.5785    1285.5785 
   22000   -13153.577   -13153.577   -13294.313   -13294.313    272.26337    272.26337    67213.577    67213.577    627.39432    627.39432 
Loop time of 137.394 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.96     | 136.96     | 136.96     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055173   | 0.055173   | 0.055173   |   0.0 |  0.04
Output  | 0.00010352 | 0.00010352 | 0.00010352 |   0.0 |  0.00
Modify  | 0.3301     | 0.3301     | 0.3301     |   0.0 |  0.24
Other   |            | 0.04976    |            |       |  0.04

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

Total # of neighbors = 284720
Ave neighs/atom = 71.180000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.793409002302, Press = 0.987589436831992
next a
jump SELF top
variable a loop 2000
run 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   -13153.577   -13153.577   -13294.313   -13294.313    272.26337    272.26337    67213.577    67213.577    627.39432    627.39432 
   23000   -13152.527   -13152.527   -13293.388   -13293.388    272.50584    272.50584    67245.795    67245.795    315.47228    315.47228 
Loop time of 140.404 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.95     | 139.95     | 139.95     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060426   | 0.060426   | 0.060426   |   0.0 |  0.04
Output  | 0.00010204 | 0.00010204 | 0.00010204 |   0.0 |  0.00
Modify  | 0.34556    | 0.34556    | 0.34556    |   0.0 |  0.25
Other   |            | 0.05254    |            |       |  0.04

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

Total # of neighbors = 284406
Ave neighs/atom = 71.101500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.780364300864, Press = 1.29057408604768
next a
jump SELF top
variable a loop 2000
run 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   -13152.527   -13152.527   -13293.388   -13293.388    272.50584    272.50584    67245.795    67245.795    315.47228    315.47228 
   24000   -13153.833   -13153.833   -13294.758   -13294.758    272.63053    272.63053     67263.73     67263.73    6.2045641    6.2045641 
Loop time of 137.268 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.82     | 136.82     | 136.82     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057696   | 0.057696   | 0.057696   |   0.0 |  0.04
Output  | 0.0001094  | 0.0001094  | 0.0001094  |   0.0 |  0.00
Modify  | 0.33549    | 0.33549    | 0.33549    |   0.0 |  0.24
Other   |            | 0.05105    |            |       |  0.04

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

Total # of neighbors = 283926
Ave neighs/atom = 70.981500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.774371864256, Press = 1.09479817869295
next a
jump SELF top
variable a loop 2000
run 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   -13153.833   -13153.833   -13294.758   -13294.758    272.63053    272.63053     67263.73     67263.73    6.2045641    6.2045641 
   25000    -13151.71    -13151.71   -13293.249   -13293.249    273.81569    273.81569    67301.262    67301.262   -364.50406   -364.50406 
Loop time of 137.469 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.02     | 137.02     | 137.02     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057616   | 0.057616   | 0.057616   |   0.0 |  0.04
Output  | 0.00011027 | 0.00011027 | 0.00011027 |   0.0 |  0.00
Modify  | 0.33483    | 0.33483    | 0.33483    |   0.0 |  0.24
Other   |            | 0.05175    |            |       |  0.04

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

Total # of neighbors = 283746
Ave neighs/atom = 70.936500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.692364130808, Press = 0.675177005414569
next a
jump SELF top
variable a loop 2000
run 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    -13151.71    -13151.71   -13293.249   -13293.249    273.81569    273.81569    67301.262    67301.262   -364.50406   -364.50406 
   26000   -13152.303   -13152.303   -13293.031   -13293.031    272.24893    272.24893    67307.475    67307.475   -393.94655   -393.94655 
Loop time of 138.281 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.84     | 137.84     | 137.84     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058077   | 0.058077   | 0.058077   |   0.0 |  0.04
Output  | 0.00011235 | 0.00011235 | 0.00011235 |   0.0 |  0.00
Modify  | 0.33698    | 0.33698    | 0.33698    |   0.0 |  0.24
Other   |            | 0.05116    |            |       |  0.04

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

Total # of neighbors = 283510
Ave neighs/atom = 70.877500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.763737191519, Press = 0.475195906549772
next a
jump SELF top
variable a loop 2000
run 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   -13152.303   -13152.303   -13293.031   -13293.031    272.24893    272.24893    67307.475    67307.475   -393.94655   -393.94655 
   27000   -13158.916   -13158.916   -13297.292   -13297.292    267.69875    267.69875    67288.923    67288.923   -493.55766   -493.55766 
Loop time of 141.161 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.612 ns/day, 39.211 hours/ns, 7.084 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.69     | 140.69     | 140.69     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0618     | 0.0618     | 0.0618     |   0.0 |  0.04
Output  | 0.00010827 | 0.00010827 | 0.00010827 |   0.0 |  0.00
Modify  | 0.3499     | 0.3499     | 0.3499     |   0.0 |  0.25
Other   |            | 0.05474    |            |       |  0.04

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

Total # of neighbors = 283550
Ave neighs/atom = 70.887500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.697694084097, Press = -0.0775935584107258
next a
jump SELF top
variable a loop 2000
run 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   -13158.916   -13158.916   -13297.292   -13297.292    267.69875    267.69875    67288.923    67288.923   -493.55766   -493.55766 
   28000   -13150.872   -13150.872   -13292.541   -13292.541    274.06971    274.06971    67278.442    67278.442   -37.432786   -37.432786 
Loop time of 138.191 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.625 ns/day, 38.386 hours/ns, 7.236 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    | 137.74     | 137.74     | 137.74     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058472   | 0.058472   | 0.058472   |   0.0 |  0.04
Output  | 0.000118   | 0.000118   | 0.000118   |   0.0 |  0.00
Modify  | 0.33687    | 0.33687    | 0.33687    |   0.0 |  0.24
Other   |            | 0.05126    |            |       |  0.04

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

Total # of neighbors = 283902
Ave neighs/atom = 70.975500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.688220492681, Press = -1.03527866955931
next a
jump SELF top
variable a loop 2000
run 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   -13150.872   -13150.872   -13292.541   -13292.541    274.06971    274.06971    67278.442    67278.442   -37.432786   -37.432786 
   29000   -13150.893   -13150.893    -13292.71    -13292.71    274.35445    274.35445    67240.186    67240.186    416.74051    416.74051 
Loop time of 138.927 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.48     | 138.48     | 138.48     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059653   | 0.059653   | 0.059653   |   0.0 |  0.04
Output  | 0.00012128 | 0.00012128 | 0.00012128 |   0.0 |  0.00
Modify  | 0.34003    | 0.34003    | 0.34003    |   0.0 |  0.24
Other   |            | 0.05176    |            |       |  0.04

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

Total # of neighbors = 283462
Ave neighs/atom = 70.865500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.725243908202, Press = -1.23707057946741
next a
jump SELF top
variable a loop 2000
run 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   -13150.893   -13150.893    -13292.71    -13292.71    274.35445    274.35445    67240.186    67240.186    416.74051    416.74051 
   30000   -13157.491   -13157.491   -13298.586   -13298.586    272.95685    272.95685    67190.733    67190.733    568.45183    568.45183 
Loop time of 138.76 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.31     | 138.31     | 138.31     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059238   | 0.059238   | 0.059238   |   0.0 |  0.04
Output  | 0.00011344 | 0.00011344 | 0.00011344 |   0.0 |  0.00
Modify  | 0.3386     | 0.3386     | 0.3386     |   0.0 |  0.24
Other   |            | 0.05149    |            |       |  0.04

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

Total # of neighbors = 283898
Ave neighs/atom = 70.974500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.702379733112, Press = -0.415876930234379
next a
jump SELF top
variable a loop 2000
run 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   -13157.491   -13157.491   -13298.586   -13298.586    272.95685    272.95685    67190.733    67190.733    568.45183    568.45183 
   31000   -13152.547   -13152.547   -13292.699   -13292.699    271.13331    271.13331    67247.086    67247.086    281.93135    281.93135 
Loop time of 136.947 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.51     | 136.51     | 136.51     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055621   | 0.055621   | 0.055621   |   0.0 |  0.04
Output  | 0.00010758 | 0.00010758 | 0.00010758 |   0.0 |  0.00
Modify  | 0.32982    | 0.32982    | 0.32982    |   0.0 |  0.24
Other   |            | 0.04986    |            |       |  0.04

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

Total # of neighbors = 284694
Ave neighs/atom = 71.173500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.67766388091, Press = 0.168467665436606
next a
jump SELF top
variable a loop 2000
run 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   -13152.547   -13152.547   -13292.699   -13292.699    271.13331    271.13331    67247.086    67247.086    281.93135    281.93135 
   32000    -13148.65    -13148.65    -13290.81    -13290.81    275.01797    275.01797    67260.648    67260.648    335.22861    335.22861 
Loop time of 132.162 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.654 ns/day, 36.712 hours/ns, 7.566 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.75     | 131.75     | 131.75     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052613   | 0.052613   | 0.052613   |   0.0 |  0.04
Output  | 0.00010745 | 0.00010745 | 0.00010745 |   0.0 |  0.00
Modify  | 0.31391    | 0.31391    | 0.31391    |   0.0 |  0.24
Other   |            | 0.04811    |            |       |  0.04

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

Total # of neighbors = 283920
Ave neighs/atom = 70.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.715329402698, Press = 0.184667713120844
next a
jump SELF top
variable a loop 2000
run 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    -13148.65    -13148.65    -13290.81    -13290.81    275.01797    275.01797    67260.648    67260.648    335.22861    335.22861 
   33000   -13154.849   -13154.849   -13294.597   -13294.597    270.35243    270.35243    67238.154    67238.154    318.54313    318.54313 
Loop time of 132.604 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.652 ns/day, 36.834 hours/ns, 7.541 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.19     | 132.19     | 132.19     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052305   | 0.052305   | 0.052305   |   0.0 |  0.04
Output  | 0.00010653 | 0.00010653 | 0.00010653 |   0.0 |  0.00
Modify  | 0.31592    | 0.31592    | 0.31592    |   0.0 |  0.24
Other   |            | 0.04853    |            |       |  0.04

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

Total # of neighbors = 283566
Ave neighs/atom = 70.891500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.782341733441, Press = 0.487668673560894
next a
jump SELF top
variable a loop 2000
run 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   -13154.849   -13154.849   -13294.597   -13294.597    270.35243    270.35243    67238.154    67238.154    318.54313    318.54313 
   34000   -13148.978   -13148.978   -13292.992   -13292.992    278.60539    278.60539    67215.639    67215.639    714.92168    714.92168 
Loop time of 133.328 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.648 ns/day, 37.036 hours/ns, 7.500 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.91     | 132.91     | 132.91     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053231   | 0.053231   | 0.053231   |   0.0 |  0.04
Output  | 0.00011208 | 0.00011208 | 0.00011208 |   0.0 |  0.00
Modify  | 0.31741    | 0.31741    | 0.31741    |   0.0 |  0.24
Other   |            | 0.04863    |            |       |  0.04

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

Total # of neighbors = 284048
Ave neighs/atom = 71.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.757794888408, Press = 0.981169651483455
next a
jump SELF top
variable a loop 2000
run 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   -13148.978   -13148.978   -13292.992   -13292.992    278.60539    278.60539    67215.639    67215.639    714.92168    714.92168 
   35000   -13155.223   -13155.223   -13293.716   -13293.716    267.92404    267.92404    67183.202    67183.202    997.20368    997.20368 
Loop time of 135.44 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.01     | 135.01     | 135.01     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052441   | 0.052441   | 0.052441   |   0.0 |  0.04
Output  | 0.00011065 | 0.00011065 | 0.00011065 |   0.0 |  0.00
Modify  | 0.32423    | 0.32423    | 0.32423    |   0.0 |  0.24
Other   |            | 0.04996    |            |       |  0.04

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

Total # of neighbors = 283932
Ave neighs/atom = 70.983000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.749253913056, Press = 1.15363097593142
next a
jump SELF top
variable a loop 2000
run 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   -13155.223   -13155.223   -13293.716   -13293.716    267.92404    267.92404    67183.202    67183.202    997.20368    997.20368 
   36000   -13149.187   -13149.187   -13292.231   -13292.231     276.7284     276.7284    67235.355    67235.355    568.77152    568.77152 
Loop time of 134.137 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.644 ns/day, 37.260 hours/ns, 7.455 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.71     | 133.71     | 133.71     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052661   | 0.052661   | 0.052661   |   0.0 |  0.04
Output  | 0.00010612 | 0.00010612 | 0.00010612 |   0.0 |  0.00
Modify  | 0.31997    | 0.31997    | 0.31997    |   0.0 |  0.24
Other   |            | 0.05051    |            |       |  0.04

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

Total # of neighbors = 284544
Ave neighs/atom = 71.136000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.774215288952, Press = 1.13129348683851
next a
jump SELF top
variable a loop 2000
run 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   -13149.187   -13149.187   -13292.231   -13292.231     276.7284     276.7284    67235.355    67235.355    568.77152    568.77152 
   37000   -13155.136   -13155.136   -13295.927   -13295.927    272.37076    272.37076    67238.307    67238.307    186.85353    186.85353 
Loop time of 132.832 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.650 ns/day, 36.898 hours/ns, 7.528 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    | 132.41     | 132.41     | 132.41     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052474   | 0.052474   | 0.052474   |   0.0 |  0.04
Output  | 0.00010473 | 0.00010473 | 0.00010473 |   0.0 |  0.00
Modify  | 0.31626    | 0.31626    | 0.31626    |   0.0 |  0.24
Other   |            | 0.04946    |            |       |  0.04

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

Total # of neighbors = 283890
Ave neighs/atom = 70.972500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.772192594685, Press = 1.08884378835225
next a
jump SELF top
variable a loop 2000
run 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   -13155.136   -13155.136   -13295.927   -13295.927    272.37076    272.37076    67238.307    67238.307    186.85353    186.85353 
   38000   -13151.363   -13151.363   -13291.119   -13291.119    270.36782    270.36782    67275.635    67275.635    139.41854    139.41854 
Loop time of 133.704 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.646 ns/day, 37.140 hours/ns, 7.479 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.28     | 133.28     | 133.28     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052924   | 0.052924   | 0.052924   |   0.0 |  0.04
Output  | 0.0001057  | 0.0001057  | 0.0001057  |   0.0 |  0.00
Modify  | 0.31918    | 0.31918    | 0.31918    |   0.0 |  0.24
Other   |            | 0.05066    |            |       |  0.04

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

Total # of neighbors = 283942
Ave neighs/atom = 70.985500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.780423142828, Press = 0.673575176620682
next a
jump SELF top
variable a loop 2000
run 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   -13151.363   -13151.363   -13291.119   -13291.119    270.36782    270.36782    67275.635    67275.635    139.41854    139.41854 
   39000   -13153.681   -13153.681   -13295.194   -13295.194    273.76678    273.76678    67267.464    67267.464   -72.609275   -72.609275 
Loop time of 133.477 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.647 ns/day, 37.077 hours/ns, 7.492 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.06     | 133.06     | 133.06     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052357   | 0.052357   | 0.052357   |   0.0 |  0.04
Output  | 0.00025366 | 0.00025366 | 0.00025366 |   0.0 |  0.00
Modify  | 0.31841    | 0.31841    | 0.31841    |   0.0 |  0.24
Other   |            | 0.04944    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5840.00 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      283450.0 ave      283450 max      283450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283450
Ave neighs/atom = 70.862500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.800712157478, Press = 0.277925682461486
next a
jump SELF top
variable a loop 2000
run 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   -13153.681   -13153.681   -13295.194   -13295.194    273.76678    273.76678    67267.464    67267.464   -72.609275   -72.609275 
   40000   -13148.499   -13148.499   -13292.147   -13292.147    277.89562    277.89562    67287.885    67287.885   -79.603416   -79.603416 
Loop time of 133.129 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.649 ns/day, 36.980 hours/ns, 7.511 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.71     | 132.71     | 132.71     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052669   | 0.052669   | 0.052669   |   0.0 |  0.04
Output  | 0.00011482 | 0.00011482 | 0.00011482 |   0.0 |  0.00
Modify  | 0.3188     | 0.3188     | 0.3188     |   0.0 |  0.24
Other   |            | 0.05043    |            |       |  0.04

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

Total # of neighbors = 283998
Ave neighs/atom = 70.999500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.80988610295, Press = 0.267484813019121
next a
jump SELF top
variable a loop 2000
run 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   -13148.499   -13148.499   -13292.147   -13292.147    277.89562    277.89562    67287.885    67287.885   -79.603416   -79.603416 
   41000   -13155.963   -13155.963   -13296.464   -13296.464    271.80871    271.80871    67237.571    67237.571     151.2839     151.2839 
Loop time of 136.208 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.634 ns/day, 37.836 hours/ns, 7.342 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    | 135.77     | 135.77     | 135.77     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054204   | 0.054204   | 0.054204   |   0.0 |  0.04
Output  | 0.00024538 | 0.00024538 | 0.00024538 |   0.0 |  0.00
Modify  | 0.32881    | 0.32881    | 0.32881    |   0.0 |  0.24
Other   |            | 0.05225    |            |       |  0.04

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

Total # of neighbors = 283304
Ave neighs/atom = 70.826000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.786178425197, Press = 0.189340330005489
next a
jump SELF top
variable a loop 2000
run 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   -13155.963   -13155.963   -13296.464   -13296.464    271.80871    271.80871    67237.571    67237.571     151.2839     151.2839 
   42000   -13149.339   -13149.339   -13294.219   -13294.219    280.28008    280.28008    67220.074    67220.074    615.62665    615.62665 
Loop time of 134.298 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.643 ns/day, 37.305 hours/ns, 7.446 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.87     | 133.87     | 133.87     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054298   | 0.054298   | 0.054298   |   0.0 |  0.04
Output  | 0.00010502 | 0.00010502 | 0.00010502 |   0.0 |  0.00
Modify  | 0.32307    | 0.32307    | 0.32307    |   0.0 |  0.24
Other   |            | 0.05076    |            |       |  0.04

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

Total # of neighbors = 284206
Ave neighs/atom = 71.051500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.771970359488, Press = 0.0661438358678483
next a
jump SELF top
variable a loop 2000
run 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   -13149.339   -13149.339   -13294.219   -13294.219    280.28008    280.28008    67220.074    67220.074    615.62665    615.62665 
   43000   -13153.258   -13153.258   -13293.906   -13293.906    272.09206    272.09206    67186.579    67186.579    932.30422    932.30422 
Loop time of 135.056 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.640 ns/day, 37.515 hours/ns, 7.404 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.63     | 134.63     | 134.63     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052561   | 0.052561   | 0.052561   |   0.0 |  0.04
Output  | 0.00010627 | 0.00010627 | 0.00010627 |   0.0 |  0.00
Modify  | 0.32222    | 0.32222    | 0.32222    |   0.0 |  0.24
Other   |            | 0.04941    |            |       |  0.04

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

Total # of neighbors = 284116
Ave neighs/atom = 71.029000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.806362181636, Press = 0.171212490132192
next a
jump SELF top
variable a loop 2000
run 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   -13153.258   -13153.258   -13293.906   -13293.906    272.09206    272.09206    67186.579    67186.579    932.30422    932.30422 
   44000     -13149.2     -13149.2   -13294.472   -13294.472     281.0375     281.0375    67180.814    67180.814    998.54138    998.54138 
Loop time of 134.063 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.644 ns/day, 37.240 hours/ns, 7.459 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.64     | 133.64     | 133.64     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052679   | 0.052679   | 0.052679   |   0.0 |  0.04
Output  | 0.00010309 | 0.00010309 | 0.00010309 |   0.0 |  0.00
Modify  | 0.32163    | 0.32163    | 0.32163    |   0.0 |  0.24
Other   |            | 0.05101    |            |       |  0.04

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

Total # of neighbors = 284324
Ave neighs/atom = 71.081000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.813336896066, Press = 0.72888927877184
next a
jump SELF top
variable a loop 2000
run 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     -13149.2     -13149.2   -13294.472   -13294.472     281.0375     281.0375    67180.814    67180.814    998.54138    998.54138 
   45000   -13152.205   -13152.205   -13293.921   -13293.921    274.15816    274.15816    67190.463    67190.463    891.51149    891.51149 
Loop time of 132.403 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.653 ns/day, 36.778 hours/ns, 7.553 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    | 131.98     | 131.98     | 131.98     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052583   | 0.052583   | 0.052583   |   0.0 |  0.04
Output  | 0.00010708 | 0.00010708 | 0.00010708 |   0.0 |  0.00
Modify  | 0.31964    | 0.31964    | 0.31964    |   0.0 |  0.24
Other   |            | 0.05309    |            |       |  0.04

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

Total # of neighbors = 284376
Ave neighs/atom = 71.094000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.858280049592, Press = 0.721179238061232
next a
jump SELF top
variable a loop 2000
run 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   -13152.205   -13152.205   -13293.921   -13293.921    274.15816    274.15816    67190.463    67190.463    891.51149    891.51149 
   46000   -13149.419   -13149.419   -13291.335   -13291.335    274.54482    274.54482    67270.525    67270.525     229.4052     229.4052 
Loop time of 133.511 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.08     | 133.08     | 133.08     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052935   | 0.052935   | 0.052935   |   0.0 |  0.04
Output  | 0.00011101 | 0.00011101 | 0.00011101 |   0.0 |  0.00
Modify  | 0.32318    | 0.32318    | 0.32318    |   0.0 |  0.24
Other   |            | 0.05306    |            |       |  0.04

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

Total # of neighbors = 284346
Ave neighs/atom = 71.086500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.859102633044, Press = 0.566742898956241
next a
jump SELF top
variable a loop 2000
run 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   -13149.419   -13149.419   -13291.335   -13291.335    274.54482    274.54482    67270.525    67270.525     229.4052     229.4052 
   47000   -13150.877   -13150.877     -13292.5     -13292.5      273.979      273.979    67274.909    67274.909    49.835176    49.835176 
Loop time of 136.822 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.631 ns/day, 38.006 hours/ns, 7.309 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.39     | 136.39     | 136.39     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052724   | 0.052724   | 0.052724   |   0.0 |  0.04
Output  | 0.00024851 | 0.00024851 | 0.00024851 |   0.0 |  0.00
Modify  | 0.33081    | 0.33081    | 0.33081    |   0.0 |  0.24
Other   |            | 0.05094    |            |       |  0.04

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

Total # of neighbors = 283714
Ave neighs/atom = 70.928500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.926398081179, Press = 0.47829056860378
next a
jump SELF top
variable a loop 2000
run 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   -13150.877   -13150.877     -13292.5     -13292.5      273.979      273.979    67274.909    67274.909    49.835176    49.835176 
   48000   -13155.336   -13155.336   -13295.708   -13295.708    271.55941    271.55941    67276.513    67276.513   -192.11522   -192.11522 
Loop time of 134.948 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.640 ns/day, 37.485 hours/ns, 7.410 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.52     | 134.52     | 134.52     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05283    | 0.05283    | 0.05283    |   0.0 |  0.04
Output  | 0.00010789 | 0.00010789 | 0.00010789 |   0.0 |  0.00
Modify  | 0.32372    | 0.32372    | 0.32372    |   0.0 |  0.24
Other   |            | 0.04986    |            |       |  0.04

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

Total # of neighbors = 283798
Ave neighs/atom = 70.949500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.921071399329, Press = 0.629754991275261
next a
jump SELF top
variable a loop 2000
run 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   -13155.336   -13155.336   -13295.708   -13295.708    271.55941    271.55941    67276.513    67276.513   -192.11522   -192.11522 
   49000   -13146.342   -13146.342       -13290       -13290    277.91698    277.91698    67342.336    67342.336   -473.84758   -473.84758 
Loop time of 131.096 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.659 ns/day, 36.415 hours/ns, 7.628 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.67     | 130.67     | 130.67     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052277   | 0.052277   | 0.052277   |   0.0 |  0.04
Output  | 0.00010406 | 0.00010406 | 0.00010406 |   0.0 |  0.00
Modify  | 0.31641    | 0.31641    | 0.31641    |   0.0 |  0.24
Other   |            | 0.05195    |            |       |  0.04

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

Total # of neighbors = 283566
Ave neighs/atom = 70.891500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.932170639311, Press = 0.826783249953099
next a
jump SELF top
variable a loop 2000
run 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   -13146.342   -13146.342       -13290       -13290    277.91698    277.91698    67342.336    67342.336   -473.84758   -473.84758 
   50000   -13154.913   -13154.913   -13296.318   -13296.318    273.55705    273.55705    67359.041    67359.041   -1141.9776   -1141.9776 
Loop time of 132.114 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.654 ns/day, 36.698 hours/ns, 7.569 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    | 131.7      | 131.7      | 131.7      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052088   | 0.052088   | 0.052088   |   0.0 |  0.04
Output  | 0.0001874  | 0.0001874  | 0.0001874  |   0.0 |  0.00
Modify  | 0.31323    | 0.31323    | 0.31323    |   0.0 |  0.24
Other   |            | 0.04813    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.957973956108, Press = 1.02332918889548
next a
jump SELF top
variable a loop 2000
run 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   -13154.913   -13154.913   -13296.318   -13296.318    273.55705    273.55705    67359.041    67359.041   -1141.9776   -1141.9776 
   51000   -13148.484   -13148.484   -13294.441   -13294.441    282.36326    282.36326    67367.682    67367.682   -1043.5737   -1043.5737 
Loop time of 130.32 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.663 ns/day, 36.200 hours/ns, 7.673 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.91     | 129.91     | 129.91     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051282   | 0.051282   | 0.051282   |   0.0 |  0.04
Output  | 0.0001211  | 0.0001211  | 0.0001211  |   0.0 |  0.00
Modify  | 0.30894    | 0.30894    | 0.30894    |   0.0 |  0.24
Other   |            | 0.04866    |            |       |  0.04

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

Total # of neighbors = 282782
Ave neighs/atom = 70.695500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.988651552625, Press = 0.301027799153267
next a
jump SELF top
variable a loop 2000
run 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   -13148.484   -13148.484   -13294.441   -13294.441    282.36326    282.36326    67367.682    67367.682   -1043.5737   -1043.5737 
   52000   -13153.925   -13153.925   -13294.833   -13294.833     272.5955     272.5955    67310.915    67310.915   -491.34193   -491.34193 
Loop time of 129.361 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.668 ns/day, 35.934 hours/ns, 7.730 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.96     | 128.96     | 128.96     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051104   | 0.051104   | 0.051104   |   0.0 |  0.04
Output  | 0.00024427 | 0.00024427 | 0.00024427 |   0.0 |  0.00
Modify  | 0.30501    | 0.30501    | 0.30501    |   0.0 |  0.24
Other   |            | 0.04719    |            |       |  0.04

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0