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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.163879469037056*${_u_distance}
variable latticeconst_converted equal 3.163879469037056*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.16387946903706
Lattice spacing in x,y,z = 3.1638795 3.1638795 3.1638795
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 (31.638795 31.638795 31.638795)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (31.638795 31.638795 31.638795)
  create_atoms CPU = 0.003 seconds

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

kim_interactions W

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

kim interactions W
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_ShimParkCho_2003_NiW__MO_500937681860_001
pair_coeff * * W
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 183.84

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 31670.855213091 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_500937681860_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17233.917   -17233.917       -17320       -17320       333.15       333.15    31670.855    31670.855    2903.1659    2903.1659 
    1000   -17145.331   -17145.331   -17233.412   -17233.412    340.88333    340.88333    31772.678    31772.678    2854.1024    2854.1024 
Loop time of 168.268 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.513 ns/day, 46.741 hours/ns, 5.943 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    | 167.75     | 167.75     | 167.75     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099465   | 0.099465   | 0.099465   |   0.0 |  0.06
Output  | 0.00019638 | 0.00019638 | 0.00019638 |   0.0 |  0.00
Modify  | 0.36184    | 0.36184    | 0.36184    |   0.0 |  0.22
Other   |            | 0.06126    |            |       |  0.04

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

Total # of neighbors = 128000
Ave neighs/atom = 64.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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -17145.331   -17145.331   -17233.412   -17233.412    340.88333    340.88333    31772.678    31772.678    2854.1024    2854.1024 
    2000   -17144.998   -17144.998    -17229.24    -17229.24     326.0274     326.0274    31809.899    31809.899   -449.18643   -449.18643 
Loop time of 164.643 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.525 ns/day, 45.734 hours/ns, 6.074 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    | 164.13     | 164.13     | 164.13     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097387   | 0.097387   | 0.097387   |   0.0 |  0.06
Output  | 0.0001901  | 0.0001901  | 0.0001901  |   0.0 |  0.00
Modify  | 0.35035    | 0.35035    | 0.35035    |   0.0 |  0.21
Other   |            | 0.06148    |            |       |  0.04

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

Total # of neighbors = 127944
Ave neighs/atom = 63.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 = 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -17144.998   -17144.998    -17229.24    -17229.24     326.0274     326.0274    31809.899    31809.899   -449.18643   -449.18643 
    3000   -17147.306   -17147.306   -17239.117   -17239.117    355.32094    355.32094     31853.73     31853.73   -5917.8229   -5917.8229 
Loop time of 168.065 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.514 ns/day, 46.685 hours/ns, 5.950 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    | 167.54     | 167.54     | 167.54     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099129   | 0.099129   | 0.099129   |   0.0 |  0.06
Output  | 0.00019084 | 0.00019084 | 0.00019084 |   0.0 |  0.00
Modify  | 0.35989    | 0.35989    | 0.35989    |   0.0 |  0.21
Other   |            | 0.06197    |            |       |  0.04

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

Total # of neighbors = 127896
Ave neighs/atom = 63.948000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17147.306   -17147.306   -17239.117   -17239.117    355.32094    355.32094     31853.73     31853.73   -5917.8229   -5917.8229 
    4000   -17145.329   -17145.329   -17225.743   -17225.743    311.20983    311.20983    31812.417    31812.417   -378.07398   -378.07398 
Loop time of 175.805 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.491 ns/day, 48.835 hours/ns, 5.688 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    | 175.25     | 175.25     | 175.25     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10288    | 0.10288    | 0.10288    |   0.0 |  0.06
Output  | 0.00018846 | 0.00018846 | 0.00018846 |   0.0 |  0.00
Modify  | 0.38387    | 0.38387    | 0.38387    |   0.0 |  0.22
Other   |            | 0.06432    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127894.0 ave      127894 max      127894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127894
Ave neighs/atom = 63.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 = 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -17145.329   -17145.329   -17225.743   -17225.743    311.20983    311.20983    31812.417    31812.417   -378.07398   -378.07398 
    5000   -17146.487   -17146.487   -17231.867   -17231.867    330.42985    330.42985    31825.893    31825.893   -2313.9285   -2313.9285 
Loop time of 174.909 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.494 ns/day, 48.586 hours/ns, 5.717 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    | 174.36     | 174.36     | 174.36     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10219    | 0.10219    | 0.10219    |   0.0 |  0.06
Output  | 0.00015353 | 0.00015353 | 0.00015353 |   0.0 |  0.00
Modify  | 0.38244    | 0.38244    | 0.38244    |   0.0 |  0.22
Other   |            | 0.06368    |            |       |  0.04

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

Total # of neighbors = 127884
Ave neighs/atom = 63.942000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.26069149323, Press = 186.743234248456
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -17146.487   -17146.487   -17231.867   -17231.867    330.42985    330.42985    31825.893    31825.893   -2313.9285   -2313.9285 
    6000   -17145.363   -17145.363   -17234.641   -17234.641    345.51677    345.51677    31838.789    31838.789   -4091.9209   -4091.9209 
Loop time of 171.878 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.503 ns/day, 47.744 hours/ns, 5.818 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    | 171.32     | 171.32     | 171.32     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10226    | 0.10226    | 0.10226    |   0.0 |  0.06
Output  | 0.00023978 | 0.00023978 | 0.00023978 |   0.0 |  0.00
Modify  | 0.39282    | 0.39282    | 0.39282    |   0.0 |  0.23
Other   |            | 0.06242    |            |       |  0.04

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

Total # of neighbors = 127902
Ave neighs/atom = 63.951000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.737131702186, Press = 33.5480468498905
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -17145.363   -17145.363   -17234.641   -17234.641    345.51677    345.51677    31838.789    31838.789   -4091.9209   -4091.9209 
    7000   -17146.467   -17146.467   -17228.264   -17228.264    316.56135    316.56135    31805.353    31805.353   -27.540963   -27.540963 
Loop time of 173.198 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.110 hours/ns, 5.774 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    | 172.64     | 172.64     | 172.64     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1021     | 0.1021     | 0.1021     |   0.0 |  0.06
Output  | 0.00015297 | 0.00015297 | 0.00015297 |   0.0 |  0.00
Modify  | 0.39599    | 0.39599    | 0.39599    |   0.0 |  0.23
Other   |            | 0.06314    |            |       |  0.04

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

Total # of neighbors = 127874
Ave neighs/atom = 63.937000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.682506874378, Press = 14.2576959968893
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -17146.467   -17146.467   -17228.264   -17228.264    316.56135    316.56135    31805.353    31805.353   -27.540963   -27.540963 
    8000   -17147.088   -17147.088   -17237.107   -17237.107    348.38277    348.38277     31845.75     31845.75   -4774.2885   -4774.2885 
Loop time of 177.816 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.486 ns/day, 49.393 hours/ns, 5.624 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 177.24     | 177.24     | 177.24     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10437    | 0.10437    | 0.10437    |   0.0 |  0.06
Output  | 0.00015339 | 0.00015339 | 0.00015339 |   0.0 |  0.00
Modify  | 0.41188    | 0.41188    | 0.41188    |   0.0 |  0.23
Other   |            | 0.06443    |            |       |  0.04

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

Total # of neighbors = 127908
Ave neighs/atom = 63.954000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.054396749412, Press = 12.2968873986467
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17147.088   -17147.088   -17237.107   -17237.107    348.38277    348.38277     31845.75     31845.75   -4774.2885   -4774.2885 
    9000    -17145.35    -17145.35   -17229.783   -17229.783    326.76358    326.76358    31841.558    31841.558   -3856.6788   -3856.6788 
Loop time of 167.752 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.515 ns/day, 46.598 hours/ns, 5.961 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    | 167.21     | 167.21     | 167.21     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098835   | 0.098835   | 0.098835   |   0.0 |  0.06
Output  | 0.00019202 | 0.00019202 | 0.00019202 |   0.0 |  0.00
Modify  | 0.37749    | 0.37749    | 0.37749    |   0.0 |  0.23
Other   |            | 0.06146    |            |       |  0.04

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

Total # of neighbors = 127896
Ave neighs/atom = 63.948000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.995463753899, Press = 24.0872910839519
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000    -17145.35    -17145.35   -17229.783   -17229.783    326.76358    326.76358    31841.558    31841.558   -3856.6788   -3856.6788 
   10000   -17147.374   -17147.374   -17228.089   -17228.089    312.37628    312.37628    31796.371    31796.371    676.86967    676.86967 
Loop time of 171.982 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.502 ns/day, 47.773 hours/ns, 5.815 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    | 171.42     | 171.42     | 171.42     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10101    | 0.10101    | 0.10101    |   0.0 |  0.06
Output  | 0.00015419 | 0.00015419 | 0.00015419 |   0.0 |  0.00
Modify  | 0.39354    | 0.39354    | 0.39354    |   0.0 |  0.23
Other   |            | 0.06277    |            |       |  0.04

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

Total # of neighbors = 127892
Ave neighs/atom = 63.946000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.289160719221, Press = 12.796025957759
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17147.374   -17147.374   -17228.089   -17228.089    312.37628    312.37628    31796.371    31796.371    676.86967    676.86967 
   11000   -17143.676   -17143.676   -17229.453   -17229.453    331.96618    331.96618     31814.16     31814.16   -815.73849   -815.73849 
Loop time of 170.737 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.506 ns/day, 47.427 hours/ns, 5.857 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    | 170.18     | 170.18     | 170.18     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10074    | 0.10074    | 0.10074    |   0.0 |  0.06
Output  | 0.00015395 | 0.00015395 | 0.00015395 |   0.0 |  0.00
Modify  | 0.39062    | 0.39062    | 0.39062    |   0.0 |  0.23
Other   |            | 0.06269    |            |       |  0.04

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

Total # of neighbors = 127886
Ave neighs/atom = 63.943000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.35620427547, Press = 12.7305227086129
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -17143.676   -17143.676   -17229.453   -17229.453    331.96618    331.96618     31814.16     31814.16   -815.73849   -815.73849 
   12000   -17143.146   -17143.146   -17229.733   -17229.733    335.09772    335.09772    31859.051    31859.051   -5357.0544   -5357.0544 
Loop time of 172.271 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.502 ns/day, 47.853 hours/ns, 5.805 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    | 171.71     | 171.71     | 171.71     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10107    | 0.10107    | 0.10107    |   0.0 |  0.06
Output  | 0.00015625 | 0.00015625 | 0.00015625 |   0.0 |  0.00
Modify  | 0.39435    | 0.39435    | 0.39435    |   0.0 |  0.23
Other   |            | 0.06284    |            |       |  0.04

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

Total # of neighbors = 127878
Ave neighs/atom = 63.939000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.325892848174, Press = 17.658294973343
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17143.146   -17143.146   -17229.733   -17229.733    335.09772    335.09772    31859.051    31859.051   -5357.0544   -5357.0544 
   13000    -17147.25    -17147.25   -17230.879   -17230.879    323.65029    323.65029    31819.936    31819.936   -1666.3968   -1666.3968 
Loop time of 174.686 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.524 hours/ns, 5.725 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    | 174.12     | 174.12     | 174.12     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10214    | 0.10214    | 0.10214    |   0.0 |  0.06
Output  | 0.00020638 | 0.00020638 | 0.00020638 |   0.0 |  0.00
Modify  | 0.4018     | 0.4018     | 0.4018     |   0.0 |  0.23
Other   |            | 0.0638     |            |       |  0.04

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

Total # of neighbors = 127882
Ave neighs/atom = 63.941000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.33252365129, Press = 6.76345994889734
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000    -17147.25    -17147.25   -17230.879   -17230.879    323.65029    323.65029    31819.936    31819.936   -1666.3968   -1666.3968 
   14000   -17146.206   -17146.206   -17231.478   -17231.478    330.01119    330.01119    31820.624    31820.624   -1728.2469   -1728.2469 
Loop time of 177.788 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.486 ns/day, 49.386 hours/ns, 5.625 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    | 177.21     | 177.21     | 177.21     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10451    | 0.10451    | 0.10451    |   0.0 |  0.06
Output  | 0.00015626 | 0.00015626 | 0.00015626 |   0.0 |  0.00
Modify  | 0.4127     | 0.4127     | 0.4127     |   0.0 |  0.23
Other   |            | 0.06387    |            |       |  0.04

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

Total # of neighbors = 127884
Ave neighs/atom = 63.942000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.432713929002, Press = 1.89997802492936
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -17146.206   -17146.206   -17231.478   -17231.478    330.01119    330.01119    31820.624    31820.624   -1728.2469   -1728.2469 
   15000   -17145.511   -17145.511   -17228.621   -17228.621    321.64362    321.64362    31814.563    31814.563   -1002.7215   -1002.7215 
Loop time of 168.222 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.514 ns/day, 46.728 hours/ns, 5.945 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    | 167.68     | 167.68     | 167.68     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10022    | 0.10022    | 0.10022    |   0.0 |  0.06
Output  | 0.00045397 | 0.00045397 | 0.00045397 |   0.0 |  0.00
Modify  | 0.37937    | 0.37937    | 0.37937    |   0.0 |  0.23
Other   |            | 0.0615     |            |       |  0.04

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

Total # of neighbors = 127886
Ave neighs/atom = 63.943000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.512381014892, Press = 4.3844660317479
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -17145.511   -17145.511   -17228.621   -17228.621    321.64362    321.64362    31814.563    31814.563   -1002.7215   -1002.7215 
   16000   -17145.481   -17145.481   -17234.597   -17234.597    344.88949    344.88949    31848.877    31848.877   -4791.9415   -4791.9415 
Loop time of 166.134 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.520 ns/day, 46.148 hours/ns, 6.019 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 165.6      | 165.6      | 165.6      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098188   | 0.098188   | 0.098188   |   0.0 |  0.06
Output  | 0.00019513 | 0.00019513 | 0.00019513 |   0.0 |  0.00
Modify  | 0.37174    | 0.37174    | 0.37174    |   0.0 |  0.22
Other   |            | 0.06138    |            |       |  0.04

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

Total # of neighbors = 127880
Ave neighs/atom = 63.940000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.286733390328, Press = -4.2029159767814
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17145.481   -17145.481   -17234.597   -17234.597    344.88949    344.88949    31848.877    31848.877   -4791.9415   -4791.9415 
   17000   -17144.695   -17144.695   -17230.883   -17230.883    333.55294    333.55294    31830.207    31830.207   -2577.6786   -2577.6786 
Loop time of 170.362 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.507 ns/day, 47.323 hours/ns, 5.870 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    | 169.81     | 169.81     | 169.81     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099952   | 0.099952   | 0.099952   |   0.0 |  0.06
Output  | 0.00015405 | 0.00015405 | 0.00015405 |   0.0 |  0.00
Modify  | 0.38579    | 0.38579    | 0.38579    |   0.0 |  0.23
Other   |            | 0.06239    |            |       |  0.04

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

Total # of neighbors = 127912
Ave neighs/atom = 63.956000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.486866715226, Press = 1.33530964355972
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -17144.695   -17144.695   -17230.883   -17230.883    333.55294    333.55294    31830.207    31830.207   -2577.6786   -2577.6786 
   18000   -17148.833   -17148.833   -17229.388   -17229.388    311.75697    311.75697    31811.877    31811.877   -908.37007   -908.37007 
Loop time of 174.538 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.483 hours/ns, 5.729 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    | 173.97     | 173.97     | 173.97     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10316    | 0.10316    | 0.10316    |   0.0 |  0.06
Output  | 0.00015408 | 0.00015408 | 0.00015408 |   0.0 |  0.00
Modify  | 0.4031     | 0.4031     | 0.4031     |   0.0 |  0.23
Other   |            | 0.06369    |            |       |  0.04

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

Total # of neighbors = 127862
Ave neighs/atom = 63.931000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.510679514389, Press = 1.9345401218805
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17148.833   -17148.833   -17229.388   -17229.388    311.75697    311.75697    31811.877    31811.877   -908.37007   -908.37007 
   19000   -17145.424   -17145.424   -17232.943   -17232.943    338.70709    338.70709    31846.994    31846.994   -4553.1195   -4553.1195 
Loop time of 166.384 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.519 ns/day, 46.218 hours/ns, 6.010 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    | 165.85     | 165.85     | 165.85     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099026   | 0.099026   | 0.099026   |   0.0 |  0.06
Output  | 0.00015724 | 0.00015724 | 0.00015724 |   0.0 |  0.00
Modify  | 0.37699    | 0.37699    | 0.37699    |   0.0 |  0.23
Other   |            | 0.06217    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4115.00 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127878.0 ave      127878 max      127878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127878
Ave neighs/atom = 63.939000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.697105234765, Press = 3.67918706085426
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17145.424   -17145.424   -17232.943   -17232.943    338.70709    338.70709    31846.994    31846.994   -4553.1195   -4553.1195 
   20000   -17147.445   -17147.445   -17230.475   -17230.475    321.33337    321.33337    31779.314    31779.314    2308.9563    2308.9563 
Loop time of 173.225 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.118 hours/ns, 5.773 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    | 172.66     | 172.66     | 172.66     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10298    | 0.10298    | 0.10298    |   0.0 |  0.06
Output  | 0.00019492 | 0.00019492 | 0.00019492 |   0.0 |  0.00
Modify  | 0.39949    | 0.39949    | 0.39949    |   0.0 |  0.23
Other   |            | 0.06305    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127864.0 ave      127864 max      127864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127864
Ave neighs/atom = 63.932000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.776124665399, Press = 8.20795070652585
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17147.445   -17147.445   -17230.475   -17230.475    321.33337    321.33337    31779.314    31779.314    2308.9563    2308.9563 
   21000   -17144.936   -17144.936   -17228.414   -17228.414    323.06803    323.06803    31807.952    31807.952   -397.02239   -397.02239 
Loop time of 164.051 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.527 ns/day, 45.570 hours/ns, 6.096 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    | 163.53     | 163.53     | 163.53     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096637   | 0.096637   | 0.096637   |   0.0 |  0.06
Output  | 0.00015437 | 0.00015437 | 0.00015437 |   0.0 |  0.00
Modify  | 0.36528    | 0.36528    | 0.36528    |   0.0 |  0.22
Other   |            | 0.06053    |            |       |  0.04

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

Total # of neighbors = 127914
Ave neighs/atom = 63.957000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.818809064055, Press = 6.23481232882249
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -17144.936   -17144.936   -17228.414   -17228.414    323.06803    323.06803    31807.952    31807.952   -397.02239   -397.02239 
   22000   -17146.185   -17146.185   -17231.885   -17231.885    331.66577    331.66577    31766.953    31766.953    3203.9081    3203.9081 
Loop time of 168.06 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.514 ns/day, 46.683 hours/ns, 5.950 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    | 167.52     | 167.52     | 167.52     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10069    | 0.10069    | 0.10069    |   0.0 |  0.06
Output  | 0.0001982  | 0.0001982  | 0.0001982  |   0.0 |  0.00
Modify  | 0.37944    | 0.37944    | 0.37944    |   0.0 |  0.23
Other   |            | 0.06123    |            |       |  0.04

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

Total # of neighbors = 127896
Ave neighs/atom = 63.948000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.812587174036, Press = 4.77621885054945
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17146.185   -17146.185   -17231.885   -17231.885    331.66577    331.66577    31766.953    31766.953    3203.9081    3203.9081 
   23000   -17146.092   -17146.092   -17234.505   -17234.505    342.16911    342.16911     31748.15     31748.15    5225.4206    5225.4206 
Loop time of 169.868 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.186 hours/ns, 5.887 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    | 169.31     | 169.31     | 169.31     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10158    | 0.10158    | 0.10158    |   0.0 |  0.06
Output  | 0.00015508 | 0.00015508 | 0.00015508 |   0.0 |  0.00
Modify  | 0.39033    | 0.39033    | 0.39033    |   0.0 |  0.23
Other   |            | 0.06272    |            |       |  0.04

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

Total # of neighbors = 127938
Ave neighs/atom = 63.969000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.817257572122, Press = 3.9822638104099
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -17146.092   -17146.092   -17234.505   -17234.505    342.16911    342.16911     31748.15     31748.15    5225.4206    5225.4206 
   24000   -17146.289   -17146.289    -17229.78    -17229.78    323.11549    323.11549    31772.012    31772.012    3128.5238    3128.5238 
Loop time of 167.325 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.516 ns/day, 46.479 hours/ns, 5.976 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    | 166.79     | 166.79     | 166.79     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098992   | 0.098992   | 0.098992   |   0.0 |  0.06
Output  | 0.00021453 | 0.00021453 | 0.00021453 |   0.0 |  0.00
Modify  | 0.37613    | 0.37613    | 0.37613    |   0.0 |  0.22
Other   |            | 0.06184    |            |       |  0.04

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

Total # of neighbors = 127922
Ave neighs/atom = 63.961000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.729820216463, Press = 4.83911558055794
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -17146.289   -17146.289    -17229.78    -17229.78    323.11549    323.11549    31772.012    31772.012    3128.5238    3128.5238 
   25000    -17142.69    -17142.69   -17230.902   -17230.902    341.38774    341.38774    31792.039    31792.039    1027.4018    1027.4018 
Loop time of 175.722 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.492 ns/day, 48.812 hours/ns, 5.691 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 175.15     | 175.15     | 175.15     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10334    | 0.10334    | 0.10334    |   0.0 |  0.06
Output  | 0.00015382 | 0.00015382 | 0.00015382 |   0.0 |  0.00
Modify  | 0.40683    | 0.40683    | 0.40683    |   0.0 |  0.23
Other   |            | 0.0645     |            |       |  0.04

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

Total # of neighbors = 127888
Ave neighs/atom = 63.944000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.816503249744, Press = 4.55341282876211
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000    -17142.69    -17142.69   -17230.902   -17230.902    341.38774    341.38774    31792.039    31792.039    1027.4018    1027.4018 
   26000   -17148.878   -17148.878   -17230.014   -17230.014     314.0062     314.0062    31768.913    31768.913    3253.0607    3253.0607 
Loop time of 162.955 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.530 ns/day, 45.265 hours/ns, 6.137 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    | 162.44     | 162.44     | 162.44     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096658   | 0.096658   | 0.096658   |   0.0 |  0.06
Output  | 0.00015862 | 0.00015862 | 0.00015862 |   0.0 |  0.00
Modify  | 0.36027    | 0.36027    | 0.36027    |   0.0 |  0.22
Other   |            | 0.0606     |            |       |  0.04

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

Total # of neighbors = 127916
Ave neighs/atom = 63.958000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.70422810842, Press = 4.5234268423193
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17148.878   -17148.878   -17230.014   -17230.014     314.0062     314.0062    31768.913    31768.913    3253.0607    3253.0607 
   27000   -17144.023   -17144.023   -17236.261   -17236.261    356.97135    356.97135     31795.27     31795.27    288.45434    288.45434 
Loop time of 171.985 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.502 ns/day, 47.773 hours/ns, 5.814 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    | 171.43     | 171.43     | 171.43     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10071    | 0.10071    | 0.10071    |   0.0 |  0.06
Output  | 0.00015539 | 0.00015539 | 0.00015539 |   0.0 |  0.00
Modify  | 0.38939    | 0.38939    | 0.38939    |   0.0 |  0.23
Other   |            | 0.06229    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4118.00 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127932.0 ave      127932 max      127932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127932
Ave neighs/atom = 63.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 = 333.62803614009, Press = 2.88390137501745
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17144.023   -17144.023   -17236.261   -17236.261    356.97135    356.97135     31795.27     31795.27    288.45434    288.45434 
   28000   -17149.354   -17149.354   -17232.538   -17232.538    321.93405    321.93405    31806.023    31806.023   -652.75749   -652.75749 
Loop time of 171.457 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.504 ns/day, 47.627 hours/ns, 5.832 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    | 170.9      | 170.9      | 170.9      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10051    | 0.10051    | 0.10051    |   0.0 |  0.06
Output  | 0.00015342 | 0.00015342 | 0.00015342 |   0.0 |  0.00
Modify  | 0.38925    | 0.38925    | 0.38925    |   0.0 |  0.23
Other   |            | 0.06338    |            |       |  0.04

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

Total # of neighbors = 127920
Ave neighs/atom = 63.960000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.525353529379, Press = 3.19296705154757
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -17149.354   -17149.354   -17232.538   -17232.538    321.93405    321.93405    31806.023    31806.023   -652.75749   -652.75749 
   29000   -17145.142   -17145.142    -17229.01    -17229.01    324.58032    324.58032    31806.259    31806.259   -125.71675   -125.71675 
Loop time of 172.361 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.501 ns/day, 47.878 hours/ns, 5.802 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    | 171.8      | 171.8      | 171.8      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10251    | 0.10251    | 0.10251    |   0.0 |  0.06
Output  | 0.00025814 | 0.00025814 | 0.00025814 |   0.0 |  0.00
Modify  | 0.39684    | 0.39684    | 0.39684    |   0.0 |  0.23
Other   |            | 0.06315    |            |       |  0.04

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

Total # of neighbors = 127886
Ave neighs/atom = 63.943000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.45112557188, Press = 0.652353331734217
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -17145.142   -17145.142    -17229.01    -17229.01    324.58032    324.58032    31806.259    31806.259   -125.71675   -125.71675 
   30000   -17145.933   -17145.933   -17230.012   -17230.012    325.39481    325.39481    31805.103    31805.103    -222.9684    -222.9684 
Loop time of 167.742 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.515 ns/day, 46.595 hours/ns, 5.962 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    | 167.2      | 167.2      | 167.2      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10065    | 0.10065    | 0.10065    |   0.0 |  0.06
Output  | 0.00015816 | 0.00015816 | 0.00015816 |   0.0 |  0.00
Modify  | 0.37933    | 0.37933    | 0.37933    |   0.0 |  0.23
Other   |            | 0.06155    |            |       |  0.04

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

Total # of neighbors = 127912
Ave neighs/atom = 63.956000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.513702189797, Press = 1.80384568904037
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17145.933   -17145.933   -17230.012   -17230.012    325.39481    325.39481    31805.103    31805.103    -222.9684    -222.9684 
   31000   -17144.626   -17144.626   -17235.901   -17235.901    353.24651    353.24651    31856.827    31856.827   -5646.5793   -5646.5793 
Loop time of 169.315 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.032 hours/ns, 5.906 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    | 168.77     | 168.77     | 168.77     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10014    | 0.10014    | 0.10014    |   0.0 |  0.06
Output  | 0.00015348 | 0.00015348 | 0.00015348 |   0.0 |  0.00
Modify  | 0.3837     | 0.3837     | 0.3837     |   0.0 |  0.23
Other   |            | 0.06237    |            |       |  0.04

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

Total # of neighbors = 127906
Ave neighs/atom = 63.953000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.547623480922, Press = -0.102101474655461
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17144.626   -17144.626   -17235.901   -17235.901    353.24651    353.24651    31856.827    31856.827   -5646.5793   -5646.5793 
   32000   -17145.781   -17145.781   -17228.982   -17228.982    321.99428    321.99428    31822.703    31822.703   -1909.1527   -1909.1527 
Loop time of 172.97 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.047 hours/ns, 5.781 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.4      | 172.4      | 172.4      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10271    | 0.10271    | 0.10271    |   0.0 |  0.06
Output  | 0.00019704 | 0.00019704 | 0.00019704 |   0.0 |  0.00
Modify  | 0.40075    | 0.40075    | 0.40075    |   0.0 |  0.23
Other   |            | 0.06362    |            |       |  0.04

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

Total # of neighbors = 127900
Ave neighs/atom = 63.950000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.592245208909, Press = -0.0444883810195385
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -17145.781   -17145.781   -17228.982   -17228.982    321.99428    321.99428    31822.703    31822.703   -1909.1527   -1909.1527 
   33000   -17146.513   -17146.513   -17232.097   -17232.097    331.21756    331.21756    31813.693    31813.693   -1330.5989   -1330.5989 
Loop time of 168.511 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.513 ns/day, 46.809 hours/ns, 5.934 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    | 167.97     | 167.97     | 167.97     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09911    | 0.09911    | 0.09911    |   0.0 |  0.06
Output  | 0.00019017 | 0.00019017 | 0.00019017 |   0.0 |  0.00
Modify  | 0.3794     | 0.3794     | 0.3794     |   0.0 |  0.23
Other   |            | 0.06163    |            |       |  0.04

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

Total # of neighbors = 127870
Ave neighs/atom = 63.935000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.531625912903, Press = 1.77058411352743
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -17146.513   -17146.513   -17232.097   -17232.097    331.21756    331.21756    31813.693    31813.693   -1330.5989   -1330.5989 
   34000   -17148.136   -17148.136   -17233.804   -17233.804    331.54501    331.54501    31837.552    31837.552   -3801.9689   -3801.9689 
Loop time of 165.958 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.521 ns/day, 46.099 hours/ns, 6.026 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    | 165.43     | 165.43     | 165.43     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097954   | 0.097954   | 0.097954   |   0.0 |  0.06
Output  | 0.00015755 | 0.00015755 | 0.00015755 |   0.0 |  0.00
Modify  | 0.37198    | 0.37198    | 0.37198    |   0.0 |  0.22
Other   |            | 0.0618     |            |       |  0.04

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

Total # of neighbors = 127872
Ave neighs/atom = 63.936000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.4615925394, Press = 1.00025579666054
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -17148.136   -17148.136   -17233.804   -17233.804    331.54501    331.54501    31837.552    31837.552   -3801.9689   -3801.9689 
   35000    -17146.08    -17146.08   -17229.862   -17229.862    324.24471    324.24471    31808.902    31808.902   -575.76904   -575.76904 
Loop time of 165.523 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.522 ns/day, 45.979 hours/ns, 6.041 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    | 164.99     | 164.99     | 164.99     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097237   | 0.097237   | 0.097237   |   0.0 |  0.06
Output  | 0.00015358 | 0.00015358 | 0.00015358 |   0.0 |  0.00
Modify  | 0.37056    | 0.37056    | 0.37056    |   0.0 |  0.22
Other   |            | 0.0611     |            |       |  0.04

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

Total # of neighbors = 127900
Ave neighs/atom = 63.950000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.440205828197, Press = 1.35914057054149
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000    -17146.08    -17146.08   -17229.862   -17229.862    324.24471    324.24471    31808.902    31808.902   -575.76904   -575.76904 
   36000   -17145.004   -17145.004   -17234.681   -17234.681     347.0598     347.0598    31789.343    31789.343    1030.9851    1030.9851 
Loop time of 161.624 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.535 ns/day, 44.896 hours/ns, 6.187 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    | 161.11     | 161.11     | 161.11     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09517    | 0.09517    | 0.09517    |   0.0 |  0.06
Output  | 0.00015473 | 0.00015473 | 0.00015473 |   0.0 |  0.00
Modify  | 0.35819    | 0.35819    | 0.35819    |   0.0 |  0.22
Other   |            | 0.0607     |            |       |  0.04

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

Total # of neighbors = 127900
Ave neighs/atom = 63.950000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.436727826801, Press = 2.16912347427944
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -17145.004   -17145.004   -17234.681   -17234.681     347.0598     347.0598    31789.343    31789.343    1030.9851    1030.9851 
   37000   -17146.566   -17146.566   -17232.284   -17232.284    331.73794    331.73794    31788.428    31788.428    1212.0109    1212.0109 
Loop time of 160.687 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.538 ns/day, 44.635 hours/ns, 6.223 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    | 160.18     | 160.18     | 160.18     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094246   | 0.094246   | 0.094246   |   0.0 |  0.06
Output  | 0.0001532  | 0.0001532  | 0.0001532  |   0.0 |  0.00
Modify  | 0.35433    | 0.35433    | 0.35433    |   0.0 |  0.22
Other   |            | 0.06048    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4118.00 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127918.0 ave      127918 max      127918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127918
Ave neighs/atom = 63.959000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.456781747066, Press = 2.34556218153213
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -17146.566   -17146.566   -17232.284   -17232.284    331.73794    331.73794    31788.428    31788.428    1212.0109    1212.0109 
   38000   -17144.738   -17144.738   -17234.212   -17234.212    346.27674    346.27674    31775.115    31775.115    2530.7109    2530.7109 
Loop time of 161.2 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.536 ns/day, 44.778 hours/ns, 6.203 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    | 160.69     | 160.69     | 160.69     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094922   | 0.094922   | 0.094922   |   0.0 |  0.06
Output  | 0.00020097 | 0.00020097 | 0.00020097 |   0.0 |  0.00
Modify  | 0.35594    | 0.35594    | 0.35594    |   0.0 |  0.22
Other   |            | 0.06064    |            |       |  0.04

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

Total # of neighbors = 127918
Ave neighs/atom = 63.959000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.426260681211, Press = 1.52957390400366
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -17144.738   -17144.738   -17234.212   -17234.212    346.27674    346.27674    31775.115    31775.115    2530.7109    2530.7109 
   39000   -17146.727   -17146.727   -17232.518   -17232.518    332.02192    332.02192     31787.08     31787.08    1355.1591    1355.1591 
Loop time of 161.883 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.534 ns/day, 44.968 hours/ns, 6.177 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    | 161.37     | 161.37     | 161.37     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095243   | 0.095243   | 0.095243   |   0.0 |  0.06
Output  | 0.00015375 | 0.00015375 | 0.00015375 |   0.0 |  0.00
Modify  | 0.356      | 0.356      | 0.356      |   0.0 |  0.22
Other   |            | 0.06082    |            |       |  0.04

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

Total # of neighbors = 127910
Ave neighs/atom = 63.955000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.425039831463, Press = 1.85722350407789
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -17146.727   -17146.727   -17232.518   -17232.518    332.02192    332.02192     31787.08     31787.08    1355.1591    1355.1591 
   40000   -17143.528   -17143.528   -17229.137   -17229.137    331.31655    331.31655    31796.393    31796.393    848.98318    848.98318 
Loop time of 167.019 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.517 ns/day, 46.394 hours/ns, 5.987 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    | 166.48     | 166.48     | 166.48     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097797   | 0.097797   | 0.097797   |   0.0 |  0.06
Output  | 0.00015366 | 0.00015366 | 0.00015366 |   0.0 |  0.00
Modify  | 0.37639    | 0.37639    | 0.37639    |   0.0 |  0.23
Other   |            | 0.06172    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127930.0 ave      127930 max      127930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127930
Ave neighs/atom = 63.965000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.450203505481, Press = 0.983043129716095
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -17143.528   -17143.528   -17229.137   -17229.137    331.31655    331.31655    31796.393    31796.393    848.98318    848.98318 
   41000   -17145.094   -17145.094   -17231.261   -17231.261    333.47766    333.47766    31815.047    31815.047    -1193.154    -1193.154 
Loop time of 161.242 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.536 ns/day, 44.789 hours/ns, 6.202 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    | 160.73     | 160.73     | 160.73     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094798   | 0.094798   | 0.094798   |   0.0 |  0.06
Output  | 0.00049516 | 0.00049516 | 0.00049516 |   0.0 |  0.00
Modify  | 0.35586    | 0.35586    | 0.35586    |   0.0 |  0.22
Other   |            | 0.06039    |            |       |  0.04

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

Total # of neighbors = 127924
Ave neighs/atom = 63.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 = 333.407722890974, Press = 0.717799762734451
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -17145.094   -17145.094   -17231.261   -17231.261    333.47766    333.47766    31815.047    31815.047    -1193.154    -1193.154 
   42000   -17150.244   -17150.244   -17235.569   -17235.569    330.21848    330.21848    31796.423    31796.423    167.96332    167.96332 
Loop time of 165.534 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.522 ns/day, 45.982 hours/ns, 6.041 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    | 165        | 165        | 165        |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09709    | 0.09709    | 0.09709    |   0.0 |  0.06
Output  | 0.00020067 | 0.00020067 | 0.00020067 |   0.0 |  0.00
Modify  | 0.36923    | 0.36923    | 0.36923    |   0.0 |  0.22
Other   |            | 0.06235    |            |       |  0.04

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

Total # of neighbors = 127900
Ave neighs/atom = 63.950000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.342715459166, Press = 1.30825951513932
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -17150.244   -17150.244   -17235.569   -17235.569    330.21848    330.21848    31796.423    31796.423    167.96332    167.96332 
   43000   -17148.718   -17148.718   -17228.738   -17228.738    309.68527    309.68527    31819.499    31819.499   -1672.3318   -1672.3318 
Loop time of 169.317 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.032 hours/ns, 5.906 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    | 168.77     | 168.77     | 168.77     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09982    | 0.09982    | 0.09982    |   0.0 |  0.06
Output  | 0.00015444 | 0.00015444 | 0.00015444 |   0.0 |  0.00
Modify  | 0.38492    | 0.38492    | 0.38492    |   0.0 |  0.23
Other   |            | 0.06298    |            |       |  0.04

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

Total # of neighbors = 127912
Ave neighs/atom = 63.956000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.291813963426, Press = 1.46431432564714
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -17148.718   -17148.718   -17228.738   -17228.738    309.68527    309.68527    31819.499    31819.499   -1672.3318   -1672.3318 
   44000   -17145.571   -17145.571   -17233.826   -17233.826    341.55636    341.55636    31831.554    31831.554   -3086.3946   -3086.3946 
Loop time of 166.411 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.519 ns/day, 46.225 hours/ns, 6.009 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    | 165.88     | 165.88     | 165.88     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098545   | 0.098545   | 0.098545   |   0.0 |  0.06
Output  | 0.0001536  | 0.0001536  | 0.0001536  |   0.0 |  0.00
Modify  | 0.37195    | 0.37195    | 0.37195    |   0.0 |  0.22
Other   |            | 0.06194    |            |       |  0.04

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

Total # of neighbors = 127872
Ave neighs/atom = 63.936000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.236577352557, Press = -0.456506543711154
next a
jump SELF top
variable a loop 2000
run 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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -17145.571   -17145.571   -17233.826   -17233.826    341.55636    341.55636    31831.554    31831.554   -3086.3946   -3086.3946 
   45000   -17149.248   -17149.248   -17236.061   -17236.061    335.97409    335.97409    31805.429    31805.429    -745.6075    -745.6075 
Loop time of 165.47 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.522 ns/day, 45.964 hours/ns, 6.043 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    | 164.94     | 164.94     | 164.94     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098178   | 0.098178   | 0.098178   |   0.0 |  0.06
Output  | 0.00015195 | 0.00015195 | 0.00015195 |   0.0 |  0.00
Modify  | 0.3713     | 0.3713     | 0.3713     |   0.0 |  0.22
Other   |            | 0.06163    |            |       |  0.04

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

Total # of neighbors = 127906
Ave neighs/atom = 63.953000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
31801.5006685797

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0