# 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.521391749382019*${_u_distance}
variable latticeconst_converted equal 3.521391749382019*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139174938202
Lattice spacing in x,y,z = 3.5213917 3.5213917 3.5213917
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 (35.213917 35.213917 35.213917)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (35.213917 35.213917 35.213917)
  create_atoms CPU = 0.006 seconds

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_WuLeeSu_2017_NiFe__MO_321233176498_001
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_321233176498_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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17658.806   -17658.806       -17800       -17800       273.15       273.15    43665.961    43665.961    3453.7839    3453.7839 
    1000   -17508.577   -17508.577    -17657.58    -17657.58    288.25501    288.25501    44142.338    44142.338   -1595.3467   -1595.3467 
Loop time of 323.636 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.267 ns/day, 89.899 hours/ns, 3.090 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    | 322.69     | 322.69     | 322.69     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15221    | 0.15221    | 0.15221    |   0.0 |  0.05
Output  | 0.00026423 | 0.00026423 | 0.00026423 |   0.0 |  0.00
Modify  | 0.6939     | 0.6939     | 0.6939     |   0.0 |  0.21
Other   |            | 0.09609    |            |       |  0.03

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

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

Performance: 0.230 ns/day, 104.345 hours/ns, 2.662 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    | 374.55     | 374.55     | 374.55     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16992    | 0.16992    | 0.16992    |   0.0 |  0.05
Output  | 0.00029154 | 0.00029154 | 0.00029154 |   0.0 |  0.00
Modify  | 0.81566    | 0.81566    | 0.81566    |   0.0 |  0.22
Other   |            | 0.1054     |            |       |  0.03

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

Total # of neighbors = 313692
Ave neighs/atom = 78.423000
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -17517.097   -17517.097   -17655.248   -17655.248    267.26217    267.26217    44092.267    44092.267    513.45504    513.45504 
    3000   -17516.726   -17516.726    -17657.17    -17657.17    271.69951    271.69951    44091.073    44091.073    359.78575    359.78575 
Loop time of 356.558 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.242 ns/day, 99.044 hours/ns, 2.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    | 355.53     | 355.53     | 355.53     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16242    | 0.16242    | 0.16242    |   0.0 |  0.05
Output  | 0.00021319 | 0.00021319 | 0.00021319 |   0.0 |  0.00
Modify  | 0.76238    | 0.76238    | 0.76238    |   0.0 |  0.21
Other   |            | 0.1012     |            |       |  0.03

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

Total # of neighbors = 313914
Ave neighs/atom = 78.478500
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17516.726   -17516.726    -17657.17    -17657.17    271.69951    271.69951    44091.073    44091.073    359.78575    359.78575 
    4000   -17513.956   -17513.956   -17654.336   -17654.336    271.57441    271.57441    44109.023    44109.023   -41.664597   -41.664597 
Loop time of 375.781 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.384 hours/ns, 2.661 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    | 374.69     | 374.69     | 374.69     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17006    | 0.17006    | 0.17006    |   0.0 |  0.05
Output  | 0.00032814 | 0.00032814 | 0.00032814 |   0.0 |  0.00
Modify  | 0.82049    | 0.82049    | 0.82049    |   0.0 |  0.22
Other   |            | 0.1049     |            |       |  0.03

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

Total # of neighbors = 313942
Ave neighs/atom = 78.485500
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -17513.956   -17513.956   -17654.336   -17654.336    271.57441    271.57441    44109.023    44109.023   -41.664597   -41.664597 
    5000   -17518.161   -17518.161   -17659.478   -17659.478    273.38583    273.38583    44103.642    44103.642   -295.97874   -295.97874 
Loop time of 374.804 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 373.73     | 373.73     | 373.73     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16747    | 0.16747    | 0.16747    |   0.0 |  0.04
Output  | 0.00018066 | 0.00018066 | 0.00018066 |   0.0 |  0.00
Modify  | 0.806      | 0.806      | 0.806      |   0.0 |  0.22
Other   |            | 0.105      |            |       |  0.03

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

Total # of neighbors = 313854
Ave neighs/atom = 78.463500
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 = 270.611136067679, Press = -333.668789490264
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -17518.161   -17518.161   -17659.478   -17659.478    273.38583    273.38583    44103.642    44103.642   -295.97874   -295.97874 
    6000   -17512.851   -17512.851   -17654.119   -17654.119    273.29247    273.29247    44060.629    44060.629    2027.4793    2027.4793 
Loop time of 368.186 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.274 hours/ns, 2.716 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    | 367.09     | 367.09     | 367.09     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16515    | 0.16515    | 0.16515    |   0.0 |  0.04
Output  | 0.00018036 | 0.00018036 | 0.00018036 |   0.0 |  0.00
Modify  | 0.82659    | 0.82659    | 0.82659    |   0.0 |  0.22
Other   |            | 0.1048     |            |       |  0.03

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

Total # of neighbors = 313804
Ave neighs/atom = 78.451000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.788199622969, Press = 6.19617746541555
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -17512.851   -17512.851   -17654.119   -17654.119    273.29247    273.29247    44060.629    44060.629    2027.4793    2027.4793 
    7000   -17518.113   -17518.113   -17657.601   -17657.601    269.84982    269.84982    44152.994    44152.994   -2174.9727   -2174.9727 
Loop time of 377.49 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.858 hours/ns, 2.649 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    | 376.39     | 376.39     | 376.39     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16443    | 0.16443    | 0.16443    |   0.0 |  0.04
Output  | 0.00023575 | 0.00023575 | 0.00023575 |   0.0 |  0.00
Modify  | 0.83165    | 0.83165    | 0.83165    |   0.0 |  0.22
Other   |            | 0.1066     |            |       |  0.03

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

Total # of neighbors = 314060
Ave neighs/atom = 78.515000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.017667461471, Press = 7.4225075888593
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -17518.113   -17518.113   -17657.601   -17657.601    269.84982    269.84982    44152.994    44152.994   -2174.9727   -2174.9727 
    8000   -17515.198   -17515.198   -17660.324   -17660.324    280.75567    280.75567    44097.634    44097.634   -104.30626   -104.30626 
Loop time of 352.602 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.245 ns/day, 97.945 hours/ns, 2.836 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    | 351.58     | 351.58     | 351.58     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16002    | 0.16002    | 0.16002    |   0.0 |  0.05
Output  | 0.00022077 | 0.00022077 | 0.00022077 |   0.0 |  0.00
Modify  | 0.7626     | 0.7626     | 0.7626     |   0.0 |  0.22
Other   |            | 0.1014     |            |       |  0.03

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

Total # of neighbors = 313778
Ave neighs/atom = 78.444500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.964957614613, Press = -22.1650930774426
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17515.198   -17515.198   -17660.324   -17660.324    280.75567    280.75567    44097.634    44097.634   -104.30626   -104.30626 
    9000   -17519.002   -17519.002   -17659.503   -17659.503    271.80965    271.80965    44081.577    44081.577    584.35344    584.35344 
Loop time of 324.346 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.266 ns/day, 90.096 hours/ns, 3.083 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    | 323.43     | 323.43     | 323.43     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14941    | 0.14941    | 0.14941    |   0.0 |  0.05
Output  | 0.00022783 | 0.00022783 | 0.00022783 |   0.0 |  0.00
Modify  | 0.66904    | 0.66904    | 0.66904    |   0.0 |  0.21
Other   |            | 0.0931     |            |       |  0.03

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

Total # of neighbors = 313732
Ave neighs/atom = 78.433000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.602525308007, Press = 1.69507515286412
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -17519.002   -17519.002   -17659.503   -17659.503    271.80965    271.80965    44081.577    44081.577    584.35344    584.35344 
   10000   -17509.556   -17509.556   -17653.353   -17653.353    278.18345    278.18345    44139.015    44139.015   -1088.1294   -1088.1294 
Loop time of 324.62 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.266 ns/day, 90.172 hours/ns, 3.081 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    | 323.71     | 323.71     | 323.71     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14988    | 0.14988    | 0.14988    |   0.0 |  0.05
Output  | 0.00022865 | 0.00022865 | 0.00022865 |   0.0 |  0.00
Modify  | 0.66966    | 0.66966    | 0.66966    |   0.0 |  0.21
Other   |            | 0.09329    |            |       |  0.03

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

Total # of neighbors = 313794
Ave neighs/atom = 78.448500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.920793401586, Press = -2.82756535591628
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17509.556   -17509.556   -17653.353   -17653.353    278.18345    278.18345    44139.015    44139.015   -1088.1294   -1088.1294 
   11000    -17517.61    -17517.61   -17654.684   -17654.684    265.17785    265.17785    44083.794    44083.794    857.98891    857.98891 
Loop time of 323.921 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.267 ns/day, 89.978 hours/ns, 3.087 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    | 323.01     | 323.01     | 323.01     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14611    | 0.14611    | 0.14611    |   0.0 |  0.05
Output  | 0.00017912 | 0.00017912 | 0.00017912 |   0.0 |  0.00
Modify  | 0.66531    | 0.66531    | 0.66531    |   0.0 |  0.21
Other   |            | 0.09527    |            |       |  0.03

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

Total # of neighbors = 313740
Ave neighs/atom = 78.435000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.111360594062, Press = -5.0688825434167
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000    -17517.61    -17517.61   -17654.684   -17654.684    265.17785    265.17785    44083.794    44083.794    857.98891    857.98891 
   12000   -17519.845   -17519.845    -17660.93    -17660.93    272.93849    272.93849    44077.693    44077.693    626.52294    626.52294 
Loop time of 322.961 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.268 ns/day, 89.711 hours/ns, 3.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    | 322.06     | 322.06     | 322.06     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1408     | 0.1408     | 0.1408     |   0.0 |  0.04
Output  | 0.0001785  | 0.0001785  | 0.0001785  |   0.0 |  0.00
Modify  | 0.66521    | 0.66521    | 0.66521    |   0.0 |  0.21
Other   |            | 0.0978     |            |       |  0.03

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

Total # of neighbors = 313876
Ave neighs/atom = 78.469000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.170097886508, Press = 6.06937368779868
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17519.845   -17519.845    -17660.93    -17660.93    272.93849    272.93849    44077.693    44077.693    626.52294    626.52294 
   13000   -17515.301   -17515.301   -17658.844   -17658.844    277.69305    277.69305    44168.987    44168.987   -2879.6145   -2879.6145 
Loop time of 324.032 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.267 ns/day, 90.009 hours/ns, 3.086 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 323.12     | 323.12     | 323.12     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14862    | 0.14862    | 0.14862    |   0.0 |  0.05
Output  | 0.00018217 | 0.00018217 | 0.00018217 |   0.0 |  0.00
Modify  | 0.66634    | 0.66634    | 0.66634    |   0.0 |  0.21
Other   |            | 0.09368    |            |       |  0.03

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

Total # of neighbors = 313796
Ave neighs/atom = 78.449000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.041612279863, Press = -4.17412841908287
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -17515.301   -17515.301   -17658.844   -17658.844    277.69305    277.69305    44168.987    44168.987   -2879.6145   -2879.6145 
   14000   -17520.901   -17520.901    -17661.44    -17661.44     271.8836     271.8836    44067.126    44067.126    971.66706    971.66706 
Loop time of 350.68 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.246 ns/day, 97.411 hours/ns, 2.852 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    | 349.67     | 349.67     | 349.67     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15601    | 0.15601    | 0.15601    |   0.0 |  0.04
Output  | 0.00023301 | 0.00023301 | 0.00023301 |   0.0 |  0.00
Modify  | 0.75529    | 0.75529    | 0.75529    |   0.0 |  0.22
Other   |            | 0.1013     |            |       |  0.03

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

Total # of neighbors = 313650
Ave neighs/atom = 78.412500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.838286511609, Press = -4.4297047811557
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -17520.901   -17520.901    -17661.44    -17661.44     271.8836     271.8836    44067.126    44067.126    971.66706    971.66706 
   15000    -17517.76    -17517.76   -17657.375   -17657.375    270.09615    270.09615    44096.825    44096.825    151.90687    151.90687 
Loop time of 371.058 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 103.072 hours/ns, 2.695 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.95     | 369.95     | 369.95     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16562    | 0.16562    | 0.16562    |   0.0 |  0.04
Output  | 0.00018028 | 0.00018028 | 0.00018028 |   0.0 |  0.00
Modify  | 0.83196    | 0.83196    | 0.83196    |   0.0 |  0.22
Other   |            | 0.1066     |            |       |  0.03

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

Total # of neighbors = 313742
Ave neighs/atom = 78.435500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.824923862403, Press = 1.52589211930999
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -17517.76    -17517.76   -17657.375   -17657.375    270.09615    270.09615    44096.825    44096.825    151.90687    151.90687 
   16000   -17513.577   -17513.577   -17658.038   -17658.038     279.4691     279.4691    44126.699    44126.699    -1048.809    -1048.809 
Loop time of 367.122 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 101.978 hours/ns, 2.724 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    | 366.05     | 366.05     | 366.05     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16191    | 0.16191    | 0.16191    |   0.0 |  0.04
Output  | 0.00018473 | 0.00018473 | 0.00018473 |   0.0 |  0.00
Modify  | 0.80386    | 0.80386    | 0.80386    |   0.0 |  0.22
Other   |            | 0.1044     |            |       |  0.03

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

Total # of neighbors = 313812
Ave neighs/atom = 78.453000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.76689790124, Press = -2.13168307932296
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17513.577   -17513.577   -17658.038   -17658.038     279.4691     279.4691    44126.699    44126.699    -1048.809    -1048.809 
   17000   -17520.535   -17520.535   -17660.336   -17660.336    270.45626    270.45626    44076.721    44076.721     638.3887     638.3887 
Loop time of 349.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.247 ns/day, 97.151 hours/ns, 2.859 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    | 348.73     | 348.73     | 348.73     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15527    | 0.15527    | 0.15527    |   0.0 |  0.04
Output  | 0.00022405 | 0.00022405 | 0.00022405 |   0.0 |  0.00
Modify  | 0.7594     | 0.7594     | 0.7594     |   0.0 |  0.22
Other   |            | 0.1018     |            |       |  0.03

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

Total # of neighbors = 313638
Ave neighs/atom = 78.409500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.733403814057, Press = -2.64208325842267
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -17520.535   -17520.535   -17660.336   -17660.336    270.45626    270.45626    44076.721    44076.721     638.3887     638.3887 
   18000   -17514.937   -17514.937   -17657.561   -17657.561    275.91428    275.91428    44070.081    44070.081    1203.1522    1203.1522 
Loop time of 358.731 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.241 ns/day, 99.647 hours/ns, 2.788 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 357.69     | 357.69     | 357.69     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15834    | 0.15834    | 0.15834    |   0.0 |  0.04
Output  | 0.00017854 | 0.00017854 | 0.00017854 |   0.0 |  0.00
Modify  | 0.77724    | 0.77724    | 0.77724    |   0.0 |  0.22
Other   |            | 0.1026     |            |       |  0.03

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

Total # of neighbors = 313840
Ave neighs/atom = 78.460000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.662610243662, Press = 3.64218788363971
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17514.937   -17514.937   -17657.561   -17657.561    275.91428    275.91428    44070.081    44070.081    1203.1522    1203.1522 
   19000   -17518.092   -17518.092   -17658.704   -17658.704    272.02323    272.02323    44151.325    44151.325   -2256.7228   -2256.7228 
Loop time of 373.747 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372.63     | 372.63     | 372.63     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16679    | 0.16679    | 0.16679    |   0.0 |  0.04
Output  | 0.00022623 | 0.00022623 | 0.00022623 |   0.0 |  0.00
Modify  | 0.84673    | 0.84673    | 0.84673    |   0.0 |  0.23
Other   |            | 0.107      |            |       |  0.03

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

Total # of neighbors = 313900
Ave neighs/atom = 78.475000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.633059023776, Press = -2.1292266376441
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17518.092   -17518.092   -17658.704   -17658.704    272.02323    272.02323    44151.325    44151.325   -2256.7228   -2256.7228 
   20000   -17514.864   -17514.864   -17655.588   -17655.588    272.23851    272.23851     44073.67     44073.67    1307.0588    1307.0588 
Loop time of 377.055 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.737 hours/ns, 2.652 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 375.93     | 375.93     | 375.93     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16673    | 0.16673    | 0.16673    |   0.0 |  0.04
Output  | 0.00028299 | 0.00028299 | 0.00028299 |   0.0 |  0.00
Modify  | 0.84751    | 0.84751    | 0.84751    |   0.0 |  0.22
Other   |            | 0.1073     |            |       |  0.03

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

Total # of neighbors = 313618
Ave neighs/atom = 78.404500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.662097373083, Press = -1.98690338547308
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17514.864   -17514.864   -17655.588   -17655.588    272.23851    272.23851     44073.67     44073.67    1307.0588    1307.0588 
   21000   -17515.996   -17515.996   -17660.029   -17660.029    278.64198    278.64198    44104.894    44104.894   -388.72332   -388.72332 
Loop time of 364.227 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.174 hours/ns, 2.746 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    | 363.16     | 363.16     | 363.16     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16201    | 0.16201    | 0.16201    |   0.0 |  0.04
Output  | 0.00018189 | 0.00018189 | 0.00018189 |   0.0 |  0.00
Modify  | 0.79805    | 0.79805    | 0.79805    |   0.0 |  0.22
Other   |            | 0.1039     |            |       |  0.03

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

Total # of neighbors = 313932
Ave neighs/atom = 78.483000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.677777983191, Press = 1.31819642542428
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -17515.996   -17515.996   -17660.029   -17660.029    278.64198    278.64198    44104.894    44104.894   -388.72332   -388.72332 
   22000   -17521.574   -17521.574   -17660.712   -17660.712    269.17125    269.17125    44110.705    44110.705    -816.3602    -816.3602 
Loop time of 328.184 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.263 ns/day, 91.162 hours/ns, 3.047 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    | 327.26     | 327.26     | 327.26     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14439    | 0.14439    | 0.14439    |   0.0 |  0.04
Output  | 0.00023154 | 0.00023154 | 0.00023154 |   0.0 |  0.00
Modify  | 0.68465    | 0.68465    | 0.68465    |   0.0 |  0.21
Other   |            | 0.0991     |            |       |  0.03

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

Total # of neighbors = 313716
Ave neighs/atom = 78.429000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.692533695487, Press = -1.39030761398488
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17521.574   -17521.574   -17660.712   -17660.712    269.17125    269.17125    44110.705    44110.705    -816.3602    -816.3602 
   23000   -17515.883   -17515.883   -17657.684   -17657.684    274.32354    274.32354    44091.584    44091.584    339.45343    339.45343 
Loop time of 334.41 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 92.892 hours/ns, 2.990 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    | 333.46     | 333.46     | 333.46     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14766    | 0.14766    | 0.14766    |   0.0 |  0.04
Output  | 0.00022709 | 0.00022709 | 0.00022709 |   0.0 |  0.00
Modify  | 0.70181    | 0.70181    | 0.70181    |   0.0 |  0.21
Other   |            | 0.09984    |            |       |  0.03

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

Total # of neighbors = 313710
Ave neighs/atom = 78.427500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.671133548631, Press = -0.556200806219902
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -17515.883   -17515.883   -17657.684   -17657.684    274.32354    274.32354    44091.584    44091.584    339.45343    339.45343 
   24000   -17516.485   -17516.485   -17658.089   -17658.089     273.9433     273.9433    44105.192    44105.192   -292.85173   -292.85173 
Loop time of 334.063 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.259 ns/day, 92.795 hours/ns, 2.993 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    | 333.12     | 333.12     | 333.12     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14869    | 0.14869    | 0.14869    |   0.0 |  0.04
Output  | 0.00017626 | 0.00017626 | 0.00017626 |   0.0 |  0.00
Modify  | 0.69552    | 0.69552    | 0.69552    |   0.0 |  0.21
Other   |            | 0.09535    |            |       |  0.03

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

Total # of neighbors = 313826
Ave neighs/atom = 78.456500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.659409945804, Press = -0.149488948507818
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -17516.485   -17516.485   -17658.089   -17658.089     273.9433     273.9433    44105.192    44105.192   -292.85173   -292.85173 
   25000   -17515.604   -17515.604   -17656.068   -17656.068    271.73842    271.73842    44111.795    44111.795   -377.40794   -377.40794 
Loop time of 323.95 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.267 ns/day, 89.986 hours/ns, 3.087 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    | 323.05     | 323.05     | 323.05     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14362    | 0.14362    | 0.14362    |   0.0 |  0.04
Output  | 0.00017974 | 0.00017974 | 0.00017974 |   0.0 |  0.00
Modify  | 0.66696    | 0.66696    | 0.66696    |   0.0 |  0.21
Other   |            | 0.09427    |            |       |  0.03

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

Total # of neighbors = 313816
Ave neighs/atom = 78.454000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.735557721583, Press = -0.865519311387974
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -17515.604   -17515.604   -17656.068   -17656.068    271.73842    271.73842    44111.795    44111.795   -377.40794   -377.40794 
   26000   -17518.555   -17518.555   -17656.217   -17656.217    266.31719    266.31719    44076.029    44076.029    1063.5037    1063.5037 
Loop time of 346.081 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.250 ns/day, 96.134 hours/ns, 2.889 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    | 345.09     | 345.09     | 345.09     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.154      | 0.154      | 0.154      |   0.0 |  0.04
Output  | 0.0002186  | 0.0002186  | 0.0002186  |   0.0 |  0.00
Modify  | 0.73404    | 0.73404    | 0.73404    |   0.0 |  0.21
Other   |            | 0.09931    |            |       |  0.03

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

Total # of neighbors = 313800
Ave neighs/atom = 78.450000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.821083677785, Press = -1.41342136938494
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17518.555   -17518.555   -17656.217   -17656.217    266.31719    266.31719    44076.029    44076.029    1063.5037    1063.5037 
   27000   -17519.585   -17519.585   -17660.255   -17660.255    272.13638    272.13638    44101.146    44101.146   -397.44523   -397.44523 
Loop time of 355.909 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.243 ns/day, 98.864 hours/ns, 2.810 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 354.88     | 354.88     | 354.88     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1556     | 0.1556     | 0.1556     |   0.0 |  0.04
Output  | 0.00024261 | 0.00024261 | 0.00024261 |   0.0 |  0.00
Modify  | 0.7731     | 0.7731     | 0.7731     |   0.0 |  0.22
Other   |            | 0.1036     |            |       |  0.03

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

Total # of neighbors = 313906
Ave neighs/atom = 78.476500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.848791993753, Press = 0.984861313889731
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17519.585   -17519.585   -17660.255   -17660.255    272.13638    272.13638    44101.146    44101.146   -397.44523   -397.44523 
   28000    -17515.27    -17515.27   -17656.266   -17656.266    272.76674    272.76674    44135.557    44135.557   -1380.6738   -1380.6738 
Loop time of 376.141 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.484 hours/ns, 2.659 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 375.02     | 375.02     | 375.02     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16653    | 0.16653    | 0.16653    |   0.0 |  0.04
Output  | 0.00022688 | 0.00022688 | 0.00022688 |   0.0 |  0.00
Modify  | 0.85041    | 0.85041    | 0.85041    |   0.0 |  0.23
Other   |            | 0.1071     |            |       |  0.03

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

Total # of neighbors = 313882
Ave neighs/atom = 78.470500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.811536229368, Press = -2.45048214458166
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000    -17515.27    -17515.27   -17656.266   -17656.266    272.76674    272.76674    44135.557    44135.557   -1380.6738   -1380.6738 
   29000    -17521.11    -17521.11   -17658.617   -17658.617    266.01732    266.01732    44039.518    44039.518    2339.1686    2339.1686 
Loop time of 363.083 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.856 hours/ns, 2.754 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    | 362.02     | 362.02     | 362.02     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15958    | 0.15958    | 0.15958    |   0.0 |  0.04
Output  | 0.00018031 | 0.00018031 | 0.00018031 |   0.0 |  0.00
Modify  | 0.79776    | 0.79776    | 0.79776    |   0.0 |  0.22
Other   |            | 0.1048     |            |       |  0.03

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

Total # of neighbors = 313814
Ave neighs/atom = 78.453500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.767676818098, Press = -0.838200459973568
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    -17521.11    -17521.11   -17658.617   -17658.617    266.01732    266.01732    44039.518    44039.518    2339.1686    2339.1686 
   30000   -17517.489   -17517.489   -17657.557   -17657.557    270.97171    270.97171    44107.511    44107.511   -391.53374   -391.53374 
Loop time of 377.481 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.856 hours/ns, 2.649 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    | 376.35     | 376.35     | 376.35     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16643    | 0.16643    | 0.16643    |   0.0 |  0.04
Output  | 0.0012563  | 0.0012563  | 0.0012563  |   0.0 |  0.00
Modify  | 0.85159    | 0.85159    | 0.85159    |   0.0 |  0.23
Other   |            | 0.1075     |            |       |  0.03

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

Total # of neighbors = 313886
Ave neighs/atom = 78.471500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.772481274443, Press = 0.619045523894029
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17517.489   -17517.489   -17657.557   -17657.557    270.97171    270.97171    44107.511    44107.511   -391.53374   -391.53374 
   31000   -17511.068   -17511.068   -17654.126   -17654.126    276.75569    276.75569    44110.839    44110.839   -79.024587   -79.024587 
Loop time of 358.99 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.241 ns/day, 99.719 hours/ns, 2.786 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    | 357.94     | 357.94     | 357.94     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15778    | 0.15778    | 0.15778    |   0.0 |  0.04
Output  | 0.00017432 | 0.00017432 | 0.00017432 |   0.0 |  0.00
Modify  | 0.78651    | 0.78651    | 0.78651    |   0.0 |  0.22
Other   |            | 0.1044     |            |       |  0.03

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

Total # of neighbors = 313788
Ave neighs/atom = 78.447000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.816483364212, Press = -1.13705440838049
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17511.068   -17511.068   -17654.126   -17654.126    276.75569    276.75569    44110.839    44110.839   -79.024587   -79.024587 
   32000   -17516.739   -17516.739   -17657.827   -17657.827    272.94541    272.94541    44088.271    44088.271    362.14527    362.14527 
Loop time of 341.577 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.882 hours/ns, 2.928 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    | 340.6      | 340.6      | 340.6      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15218    | 0.15218    | 0.15218    |   0.0 |  0.04
Output  | 0.00017528 | 0.00017528 | 0.00017528 |   0.0 |  0.00
Modify  | 0.72621    | 0.72621    | 0.72621    |   0.0 |  0.21
Other   |            | 0.09957    |            |       |  0.03

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

Total # of neighbors = 313938
Ave neighs/atom = 78.484500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.856081793027, Press = -0.309272637894999
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -17516.739   -17516.739   -17657.827   -17657.827    272.94541    272.94541    44088.271    44088.271    362.14527    362.14527 
   33000   -17511.809   -17511.809   -17654.959   -17654.959    276.93409    276.93409    44130.775    44130.775   -1024.3935   -1024.3935 
Loop time of 351.323 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.246 ns/day, 97.590 hours/ns, 2.846 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 350.31     | 350.31     | 350.31     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15567    | 0.15567    | 0.15567    |   0.0 |  0.04
Output  | 0.00017656 | 0.00017656 | 0.00017656 |   0.0 |  0.00
Modify  | 0.76018    | 0.76018    | 0.76018    |   0.0 |  0.22
Other   |            | 0.1007     |            |       |  0.03

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

Total # of neighbors = 313818
Ave neighs/atom = 78.454500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.938645704217, Press = -0.453404291040394
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -17511.809   -17511.809   -17654.959   -17654.959    276.93409    276.93409    44130.775    44130.775   -1024.3935   -1024.3935 
   34000   -17514.042   -17514.042   -17655.363   -17655.363    273.39687    273.39687    44090.769    44090.769    632.25609    632.25609 
Loop time of 351.488 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.246 ns/day, 97.635 hours/ns, 2.845 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 350.48     | 350.48     | 350.48     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.155      | 0.155      | 0.155      |   0.0 |  0.04
Output  | 0.00017818 | 0.00017818 | 0.00017818 |   0.0 |  0.00
Modify  | 0.7506     | 0.7506     | 0.7506     |   0.0 |  0.21
Other   |            | 0.101      |            |       |  0.03

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

Total # of neighbors = 313810
Ave neighs/atom = 78.452500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.92725544899, Press = -2.58204860119186
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -17514.042   -17514.042   -17655.363   -17655.363    273.39687    273.39687    44090.769    44090.769    632.25609    632.25609 
   35000   -17518.755   -17518.755    -17657.89    -17657.89     269.1652     269.1652    44058.052    44058.052    1631.0227    1631.0227 
Loop time of 326.798 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.264 ns/day, 90.777 hours/ns, 3.060 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 325.88     | 325.88     | 325.88     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14719    | 0.14719    | 0.14719    |   0.0 |  0.05
Output  | 0.0001796  | 0.0001796  | 0.0001796  |   0.0 |  0.00
Modify  | 0.6765     | 0.6765     | 0.6765     |   0.0 |  0.21
Other   |            | 0.09466    |            |       |  0.03

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

Total # of neighbors = 313890
Ave neighs/atom = 78.472500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.964686242805, Press = 1.29499774062638
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -17518.755   -17518.755    -17657.89    -17657.89     269.1652     269.1652    44058.052    44058.052    1631.0227    1631.0227 
   36000   -17513.491   -17513.491   -17655.893   -17655.893    275.48672    275.48672    44142.738    44142.738   -1545.9414   -1545.9414 
Loop time of 350.695 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.246 ns/day, 97.415 hours/ns, 2.851 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    | 349.69     | 349.69     | 349.69     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15391    | 0.15391    | 0.15391    |   0.0 |  0.04
Output  | 0.00022369 | 0.00022369 | 0.00022369 |   0.0 |  0.00
Modify  | 0.75225    | 0.75225    | 0.75225    |   0.0 |  0.21
Other   |            | 0.1017     |            |       |  0.03

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

Total # of neighbors = 313954
Ave neighs/atom = 78.488500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.012567634854, Press = -0.436648202123234
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -17513.491   -17513.491   -17655.893   -17655.893    275.48672    275.48672    44142.738    44142.738   -1545.9414   -1545.9414 
   37000   -17518.652   -17518.652   -17658.403   -17658.403    270.35723    270.35723     44085.35     44085.35    520.09237    520.09237 
Loop time of 324.978 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.266 ns/day, 90.272 hours/ns, 3.077 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    | 324.06     | 324.06     | 324.06     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14306    | 0.14306    | 0.14306    |   0.0 |  0.04
Output  | 0.00017634 | 0.00017634 | 0.00017634 |   0.0 |  0.00
Modify  | 0.67482    | 0.67482    | 0.67482    |   0.0 |  0.21
Other   |            | 0.09648    |            |       |  0.03

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

Total # of neighbors = 313840
Ave neighs/atom = 78.460000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.039843550475, Press = -1.21314996694856
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -17518.652   -17518.652   -17658.403   -17658.403    270.35723    270.35723     44085.35     44085.35    520.09237    520.09237 
   38000   -17512.748   -17512.748   -17655.881   -17655.881    276.90018    276.90018    44098.356    44098.356    250.42677    250.42677 
Loop time of 324.509 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.266 ns/day, 90.141 hours/ns, 3.082 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    | 323.59     | 323.59     | 323.59     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1439     | 0.1439     | 0.1439     |   0.0 |  0.04
Output  | 0.00017653 | 0.00017653 | 0.00017653 |   0.0 |  0.00
Modify  | 0.67438    | 0.67438    | 0.67438    |   0.0 |  0.21
Other   |            | 0.09649    |            |       |  0.03

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

Total # of neighbors = 313842
Ave neighs/atom = 78.460500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.047344210617, Press = 0.263861970799605
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -17512.748   -17512.748   -17655.881   -17655.881    276.90018    276.90018    44098.356    44098.356    250.42677    250.42677 
   39000   -17515.805   -17515.805   -17656.523   -17656.523    272.22847    272.22847    44116.279    44116.279   -542.58121   -542.58121 
Loop time of 356.703 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.242 ns/day, 99.084 hours/ns, 2.803 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    | 355.67     | 355.67     | 355.67     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15745    | 0.15745    | 0.15745    |   0.0 |  0.04
Output  | 0.00017762 | 0.00017762 | 0.00017762 |   0.0 |  0.00
Modify  | 0.76845    | 0.76845    | 0.76845    |   0.0 |  0.22
Other   |            | 0.1021     |            |       |  0.03

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

Total # of neighbors = 313916
Ave neighs/atom = 78.479000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.048090829183, Press = -0.659025224832249
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -17515.805   -17515.805   -17656.523   -17656.523    272.22847    272.22847    44116.279    44116.279   -542.58121   -542.58121 
   40000   -17517.135   -17517.135   -17657.762   -17657.762    272.05312    272.05312    44073.531    44073.531    1027.2913    1027.2913 
Loop time of 323.506 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.267 ns/day, 89.863 hours/ns, 3.091 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    | 322.59     | 322.59     | 322.59     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14403    | 0.14403    | 0.14403    |   0.0 |  0.04
Output  | 0.0001788  | 0.0001788  | 0.0001788  |   0.0 |  0.00
Modify  | 0.67011    | 0.67011    | 0.67011    |   0.0 |  0.21
Other   |            | 0.09666    |            |       |  0.03

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

Total # of neighbors = 313726
Ave neighs/atom = 78.431500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.04811235153, Press = -0.996524460179803
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -17517.135   -17517.135   -17657.762   -17657.762    272.05312    272.05312    44073.531    44073.531    1027.2913    1027.2913 
   41000   -17517.584   -17517.584   -17656.551   -17656.551    268.84076    268.84076     44081.55     44081.55    825.14223    825.14223 
Loop time of 323.524 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.267 ns/day, 89.868 hours/ns, 3.091 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    | 322.61     | 322.61     | 322.61     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14591    | 0.14591    | 0.14591    |   0.0 |  0.05
Output  | 0.0002313  | 0.0002313  | 0.0002313  |   0.0 |  0.00
Modify  | 0.66955    | 0.66955    | 0.66955    |   0.0 |  0.21
Other   |            | 0.09601    |            |       |  0.03

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

Total # of neighbors = 313812
Ave neighs/atom = 78.453000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.073227395938, Press = 1.53849523742321
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -17517.584   -17517.584   -17656.551   -17656.551    268.84076    268.84076     44081.55     44081.55    825.14223    825.14223 
   42000   -17514.178   -17514.178   -17654.096   -17654.096    270.68096    270.68096    44150.648    44150.648   -1862.6419   -1862.6419 
Loop time of 322.727 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.268 ns/day, 89.646 hours/ns, 3.099 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    | 321.82     | 321.82     | 321.82     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14472    | 0.14472    | 0.14472    |   0.0 |  0.04
Output  | 0.0001784  | 0.0001784  | 0.0001784  |   0.0 |  0.00
Modify  | 0.6694     | 0.6694     | 0.6694     |   0.0 |  0.21
Other   |            | 0.09747    |            |       |  0.03

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

Total # of neighbors = 313874
Ave neighs/atom = 78.468500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.043059668379, Press = -1.05132632545274
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -17514.178   -17514.178   -17654.096   -17654.096    270.68096    270.68096    44150.648    44150.648   -1862.6419   -1862.6419 
   43000   -17519.861   -17519.861   -17657.314   -17657.314    265.91265    265.91265    44073.217    44073.217    996.48379    996.48379 
Loop time of 323.115 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.267 ns/day, 89.754 hours/ns, 3.095 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 322.21     | 322.21     | 322.21     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14322    | 0.14322    | 0.14322    |   0.0 |  0.04
Output  | 0.00022405 | 0.00022405 | 0.00022405 |   0.0 |  0.00
Modify  | 0.66714    | 0.66714    | 0.66714    |   0.0 |  0.21
Other   |            | 0.096      |            |       |  0.03

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

Total # of neighbors = 313794
Ave neighs/atom = 78.448500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.015043073676, Press = -0.758121573025897
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -17519.861   -17519.861   -17657.314   -17657.314    265.91265    265.91265    44073.217    44073.217    996.48379    996.48379 
   44000   -17513.147   -17513.147   -17654.737   -17654.737    273.91539    273.91539    44105.792    44105.792    19.697846    19.697846 
Loop time of 323.113 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.267 ns/day, 89.754 hours/ns, 3.095 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 322.21     | 322.21     | 322.21     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14413    | 0.14413    | 0.14413    |   0.0 |  0.04
Output  | 0.00017779 | 0.00017779 | 0.00017779 |   0.0 |  0.00
Modify  | 0.66649    | 0.66649    | 0.66649    |   0.0 |  0.21
Other   |            | 0.09692    |            |       |  0.03

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0