# 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.003 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_MahataMukhopadhyayAsleZaeem_2022_AlNi__MO_461927113651_000
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 293.15*${_u_temperature}
variable temp_converted equal 293.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17648.467   -17648.467       -17800       -17800       293.15       293.15    43665.961    43665.961    3706.6751    3706.6751 
    1000   -17487.357   -17487.357   -17638.226   -17638.226    291.86635    291.86635    44037.631    44037.631    1948.0135    1948.0135 
Loop time of 378.187 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.052 hours/ns, 2.644 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    | 377.19     | 377.19     | 377.19     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15549    | 0.15549    | 0.15549    |   0.0 |  0.04
Output  | 0.00022759 | 0.00022759 | 0.00022759 |   0.0 |  0.00
Modify  | 0.74058    | 0.74058    | 0.74058    |   0.0 |  0.20
Other   |            | 0.1027     |            |       |  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:      344000.0 ave      344000 max      344000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 344000
Ave neighs/atom = 86.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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17487.357   -17487.357   -17638.226   -17638.226    291.86635    291.86635    44037.631    44037.631    1948.0135    1948.0135 
    2000   -17495.686   -17495.686   -17652.348   -17652.348    303.07311    303.07311    44068.855    44068.855     -330.639     -330.639 
Loop time of 359.527 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.240 ns/day, 99.869 hours/ns, 2.781 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    | 358.65     | 358.65     | 358.65     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14285    | 0.14285    | 0.14285    |   0.0 |  0.04
Output  | 0.00026135 | 0.00026135 | 0.00026135 |   0.0 |  0.00
Modify  | 0.63984    | 0.63984    | 0.63984    |   0.0 |  0.18
Other   |            | 0.09616    |            |       |  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:      342242.0 ave      342242 max      342242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342242
Ave neighs/atom = 85.560500
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17495.686   -17495.686   -17652.348   -17652.348    303.07311    303.07311    44068.855    44068.855     -330.639     -330.639 
    3000   -17495.702   -17495.702   -17648.389   -17648.389    295.38271    295.38271    44075.166    44075.166    -297.9111    -297.9111 
Loop time of 377.717 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.921 hours/ns, 2.647 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.78     | 376.78     | 376.78     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14845    | 0.14845    | 0.14845    |   0.0 |  0.04
Output  | 0.0002141  | 0.0002141  | 0.0002141  |   0.0 |  0.00
Modify  | 0.68692    | 0.68692    | 0.68692    |   0.0 |  0.18
Other   |            | 0.09889    |            |       |  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:      342292.0 ave      342292 max      342292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342292
Ave neighs/atom = 85.573000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17495.702   -17495.702   -17648.389   -17648.389    295.38271    295.38271    44075.166    44075.166    -297.9111    -297.9111 
    4000   -17493.156   -17493.156   -17641.564   -17641.564    287.10475    287.10475    44082.012    44082.012   -140.93343   -140.93343 
Loop time of 391.837 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 108.844 hours/ns, 2.552 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    | 390.86     | 390.86     | 390.86     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15359    | 0.15359    | 0.15359    |   0.0 |  0.04
Output  | 0.0002182  | 0.0002182  | 0.0002182  |   0.0 |  0.00
Modify  | 0.72532    | 0.72532    | 0.72532    |   0.0 |  0.19
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:      342336.0 ave      342336 max      342336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342336
Ave neighs/atom = 85.584000
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17493.156   -17493.156   -17641.564   -17641.564    287.10475    287.10475    44082.012    44082.012   -140.93343   -140.93343 
    5000   -17497.687   -17497.687   -17647.337   -17647.337     289.5081     289.5081    44084.708    44084.708   -650.68158   -650.68158 
Loop time of 394.602 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.612 hours/ns, 2.534 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    | 393.6      | 393.6      | 393.6      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15327    | 0.15327    | 0.15327    |   0.0 |  0.04
Output  | 0.00024722 | 0.00024722 | 0.00024722 |   0.0 |  0.00
Modify  | 0.74229    | 0.74229    | 0.74229    |   0.0 |  0.19
Other   |            | 0.1025     |            |       |  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:      342276.0 ave      342276 max      342276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342276
Ave neighs/atom = 85.569000
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 = 291.379728265973, Press = -88.0215015729018
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17497.687   -17497.687   -17647.337   -17647.337     289.5081     289.5081    44084.708    44084.708   -650.68158   -650.68158 
    6000   -17492.152   -17492.152   -17645.854   -17645.854      297.348      297.348    44090.767    44090.767   -764.47959   -764.47959 
Loop time of 421.111 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 116.975 hours/ns, 2.375 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    | 420.01     | 420.01     | 420.01     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16168    | 0.16168    | 0.16168    |   0.0 |  0.04
Output  | 0.00027115 | 0.00027115 | 0.00027115 |   0.0 |  0.00
Modify  | 0.8292     | 0.8292     | 0.8292     |   0.0 |  0.20
Other   |            | 0.1059     |            |       |  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:      342320.0 ave      342320 max      342320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342320
Ave neighs/atom = 85.580000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.790008032762, Press = -31.0318750678529
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17492.152   -17492.152   -17645.854   -17645.854      297.348      297.348    44090.767    44090.767   -764.47959   -764.47959 
    7000   -17496.966   -17496.966   -17648.923   -17648.923    293.97141    293.97141    44039.131    44039.131     1107.237     1107.237 
Loop time of 395.726 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 109.924 hours/ns, 2.527 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    | 394.71     | 394.71     | 394.71     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15536    | 0.15536    | 0.15536    |   0.0 |  0.04
Output  | 0.0002538  | 0.0002538  | 0.0002538  |   0.0 |  0.00
Modify  | 0.75869    | 0.75869    | 0.75869    |   0.0 |  0.19
Other   |            | 0.1002     |            |       |  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:      342232.0 ave      342232 max      342232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342232
Ave neighs/atom = 85.558000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.984991698986, Press = -23.8402469063177
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17496.966   -17496.966   -17648.923   -17648.923    293.97141    293.97141    44039.131    44039.131     1107.237     1107.237 
    8000   -17494.523   -17494.523   -17646.227   -17646.227    293.48266    293.48266    44007.959    44007.959    2664.6745    2664.6745 
Loop time of 419.209 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.447 hours/ns, 2.385 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    | 418.11     | 418.11     | 418.11     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16091    | 0.16091    | 0.16091    |   0.0 |  0.04
Output  | 0.00024613 | 0.00024613 | 0.00024613 |   0.0 |  0.00
Modify  | 0.82983    | 0.82983    | 0.82983    |   0.0 |  0.20
Other   |            | 0.1072     |            |       |  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:      342434.0 ave      342434 max      342434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342434
Ave neighs/atom = 85.608500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.86876206757, Press = -1.66587464882934
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17494.523   -17494.523   -17646.227   -17646.227    293.48266    293.48266    44007.959    44007.959    2664.6745    2664.6745 
    9000   -17499.332   -17499.332   -17645.475   -17645.475    282.72353    282.72353    44039.598    44039.598    1293.0635    1293.0635 
Loop time of 410.413 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 114.004 hours/ns, 2.437 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    | 409.35     | 409.35     | 409.35     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15754    | 0.15754    | 0.15754    |   0.0 |  0.04
Output  | 0.00024831 | 0.00024831 | 0.00024831 |   0.0 |  0.00
Modify  | 0.80399    | 0.80399    | 0.80399    |   0.0 |  0.20
Other   |            | 0.1038     |            |       |  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:      342484.0 ave      342484 max      342484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342484
Ave neighs/atom = 85.621000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.398607797429, Press = 7.14524787156384
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17499.332   -17499.332   -17645.475   -17645.475    282.72353    282.72353    44039.598    44039.598    1293.0635    1293.0635 
   10000   -17493.271   -17493.271   -17647.233   -17647.233    297.85025    297.85025     44077.32     44077.32   -301.37529   -301.37529 
Loop time of 401.587 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.215 ns/day, 111.552 hours/ns, 2.490 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 400.54     | 400.54     | 400.54     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15812    | 0.15812    | 0.15812    |   0.0 |  0.04
Output  | 0.00021909 | 0.00021909 | 0.00021909 |   0.0 |  0.00
Modify  | 0.7834     | 0.7834     | 0.7834     |   0.0 |  0.20
Other   |            | 0.1025     |            |       |  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:      342476.0 ave      342476 max      342476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342476
Ave neighs/atom = 85.619000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.447770651217, Press = 2.47009122017863
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17493.271   -17493.271   -17647.233   -17647.233    297.85025    297.85025     44077.32     44077.32   -301.37529   -301.37529 
   11000   -17498.824   -17498.824   -17645.537   -17645.537    283.82662    283.82662    44077.502    44077.502    -272.3648    -272.3648 
Loop time of 408.667 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.519 hours/ns, 2.447 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    | 407.6      | 407.6      | 407.6      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1588     | 0.1588     | 0.1588     |   0.0 |  0.04
Output  | 0.00023178 | 0.00023178 | 0.00023178 |   0.0 |  0.00
Modify  | 0.80155    | 0.80155    | 0.80155    |   0.0 |  0.20
Other   |            | 0.1045     |            |       |  0.03

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

Total # of neighbors = 342370
Ave neighs/atom = 85.592500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.27510861207, Press = 2.37417451981795
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17498.824   -17498.824   -17645.537   -17645.537    283.82662    283.82662    44077.502    44077.502    -272.3648    -272.3648 
   12000   -17497.591   -17497.591    -17647.14    -17647.14      289.312      289.312    44083.985    44083.985   -690.47806   -690.47806 
Loop time of 420.244 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.734 hours/ns, 2.380 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    | 419.15     | 419.15     | 419.15     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16178    | 0.16178    | 0.16178    |   0.0 |  0.04
Output  | 0.00017808 | 0.00017808 | 0.00017808 |   0.0 |  0.00
Modify  | 0.8275     | 0.8275     | 0.8275     |   0.0 |  0.20
Other   |            | 0.1056     |            |       |  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:      342386.0 ave      342386 max      342386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342386
Ave neighs/atom = 85.596500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.335924889503, Press = -1.56425625224117
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17497.591   -17497.591    -17647.14    -17647.14      289.312      289.312    44083.985    44083.985   -690.47806   -690.47806 
   13000   -17494.756   -17494.756   -17648.216   -17648.216     296.8776     296.8776     44086.48     44086.48   -764.48449   -764.48449 
Loop time of 404.918 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.477 hours/ns, 2.470 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    | 403.87     | 403.87     | 403.87     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15583    | 0.15583    | 0.15583    |   0.0 |  0.04
Output  | 0.00017719 | 0.00017719 | 0.00017719 |   0.0 |  0.00
Modify  | 0.78569    | 0.78569    | 0.78569    |   0.0 |  0.19
Other   |            | 0.1045     |            |       |  0.03

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

Total # of neighbors = 342430
Ave neighs/atom = 85.607500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.443578458989, Press = -4.0048030062539
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17494.756   -17494.756   -17648.216   -17648.216     296.8776     296.8776     44086.48     44086.48   -764.48449   -764.48449 
   14000   -17499.369   -17499.369   -17648.415   -17648.415    288.34006    288.34006    44043.034    44043.034    983.93868    983.93868 
Loop time of 420.251 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.736 hours/ns, 2.380 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    | 419.15     | 419.15     | 419.15     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16176    | 0.16176    | 0.16176    |   0.0 |  0.04
Output  | 0.00017681 | 0.00017681 | 0.00017681 |   0.0 |  0.00
Modify  | 0.83392    | 0.83392    | 0.83392    |   0.0 |  0.20
Other   |            | 0.1082     |            |       |  0.03

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

Total # of neighbors = 342368
Ave neighs/atom = 85.592000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.490534259887, Press = -4.0712130776701
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17499.369   -17499.369   -17648.415   -17648.415    288.34006    288.34006    44043.034    44043.034    983.93868    983.93868 
   15000   -17493.892   -17493.892   -17645.925   -17645.925    294.11954    294.11954     44019.94     44019.94    2140.3265    2140.3265 
Loop time of 399.207 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 110.891 hours/ns, 2.505 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    | 398.17     | 398.17     | 398.17     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15471    | 0.15471    | 0.15471    |   0.0 |  0.04
Output  | 0.00049057 | 0.00049057 | 0.00049057 |   0.0 |  0.00
Modify  | 0.77392    | 0.77392    | 0.77392    |   0.0 |  0.19
Other   |            | 0.1032     |            |       |  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:      342494.0 ave      342494 max      342494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342494
Ave neighs/atom = 85.623500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.451995768425, Press = -0.777339722958306
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17493.892   -17493.892   -17645.925   -17645.925    294.11954    294.11954     44019.94     44019.94    2140.3265    2140.3265 
   16000   -17491.865   -17491.865   -17644.708   -17644.708    295.68416    295.68416    44029.873    44029.873    1972.9697    1972.9697 
Loop time of 370.548 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.930 hours/ns, 2.699 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    | 369.61     | 369.61     | 369.61     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14824    | 0.14824    | 0.14824    |   0.0 |  0.04
Output  | 0.00017666 | 0.00017666 | 0.00017666 |   0.0 |  0.00
Modify  | 0.69725    | 0.69725    | 0.69725    |   0.0 |  0.19
Other   |            | 0.09667    |            |       |  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:      342462.0 ave      342462 max      342462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342462
Ave neighs/atom = 85.615500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.411065551522, Press = 3.28569255326867
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17491.865   -17491.865   -17644.708   -17644.708    295.68416    295.68416    44029.873    44029.873    1972.9697    1972.9697 
   17000    -17495.96    -17495.96   -17649.118   -17649.118    296.29374    296.29374    44064.652    44064.652    91.943925    91.943925 
Loop time of 406.067 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.796 hours/ns, 2.463 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    | 405.01     | 405.01     | 405.01     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1581     | 0.1581     | 0.1581     |   0.0 |  0.04
Output  | 0.00017655 | 0.00017655 | 0.00017655 |   0.0 |  0.00
Modify  | 0.79207    | 0.79207    | 0.79207    |   0.0 |  0.20
Other   |            | 0.1035     |            |       |  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:      342414.0 ave      342414 max      342414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342414
Ave neighs/atom = 85.603500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.47177951028, Press = 3.39577479468608
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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    -17495.96    -17495.96   -17649.118   -17649.118    296.29374    296.29374    44064.652    44064.652    91.943925    91.943925 
   18000   -17494.178   -17494.178   -17646.564   -17646.564    294.80072    294.80072    44099.646    44099.646   -1115.9747   -1115.9747 
Loop time of 419.052 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.403 hours/ns, 2.386 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    | 417.97     | 417.97     | 417.97     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16048    | 0.16048    | 0.16048    |   0.0 |  0.04
Output  | 0.00023328 | 0.00023328 | 0.00023328 |   0.0 |  0.00
Modify  | 0.81536    | 0.81536    | 0.81536    |   0.0 |  0.19
Other   |            | 0.1045     |            |       |  0.02

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:      342404.0 ave      342404 max      342404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342404
Ave neighs/atom = 85.601000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.369895207158, Press = 2.39732585598703
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17494.178   -17494.178   -17646.564   -17646.564    294.80072    294.80072    44099.646    44099.646   -1115.9747   -1115.9747 
   19000    -17500.57    -17500.57   -17648.349   -17648.349    285.88856    285.88856    44102.435    44102.435   -1536.6606   -1536.6606 
Loop time of 392.648 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.069 hours/ns, 2.547 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    | 391.64     | 391.64     | 391.64     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15489    | 0.15489    | 0.15489    |   0.0 |  0.04
Output  | 0.00017711 | 0.00017711 | 0.00017711 |   0.0 |  0.00
Modify  | 0.75165    | 0.75165    | 0.75165    |   0.0 |  0.19
Other   |            | 0.1019     |            |       |  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:      342324.0 ave      342324 max      342324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342324
Ave neighs/atom = 85.581000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.378929460367, Press = -0.940107147292913
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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    -17500.57    -17500.57   -17648.349   -17648.349    285.88856    285.88856    44102.435    44102.435   -1536.6606   -1536.6606 
   20000   -17494.177   -17494.177   -17646.965   -17646.965    295.57843    295.57843    44089.086    44089.086    -778.5375    -778.5375 
Loop time of 362.164 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.239 ns/day, 100.601 hours/ns, 2.761 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    | 361.26     | 361.26     | 361.26     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14332    | 0.14332    | 0.14332    |   0.0 |  0.04
Output  | 0.00017962 | 0.00017962 | 0.00017962 |   0.0 |  0.00
Modify  | 0.66763    | 0.66763    | 0.66763    |   0.0 |  0.18
Other   |            | 0.0964     |            |       |  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:      342304.0 ave      342304 max      342304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342304
Ave neighs/atom = 85.576000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.330612444034, Press = -3.12197609811387
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17494.177   -17494.177   -17646.965   -17646.965    295.57843    295.57843    44089.086    44089.086    -778.5375    -778.5375 
   21000   -17499.973   -17499.973   -17649.773   -17649.773    289.79774    289.79774    44029.825    44029.825    1384.8817    1384.8817 
Loop time of 360.132 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.240 ns/day, 100.037 hours/ns, 2.777 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    | 359.23     | 359.23     | 359.23     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1448     | 0.1448     | 0.1448     |   0.0 |  0.04
Output  | 0.00018124 | 0.00018124 | 0.00018124 |   0.0 |  0.00
Modify  | 0.66428    | 0.66428    | 0.66428    |   0.0 |  0.18
Other   |            | 0.09477    |            |       |  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:      342290.0 ave      342290 max      342290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342290
Ave neighs/atom = 85.572500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.287626771693, Press = -3.25576946449373
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17499.973   -17499.973   -17649.773   -17649.773    289.79774    289.79774    44029.825    44029.825    1384.8817    1384.8817 
   22000   -17496.672   -17496.672   -17644.057   -17644.057    285.12521    285.12521    43986.803    43986.803    3643.1858    3643.1858 
Loop time of 368.068 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.241 hours/ns, 2.717 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    | 367.13     | 367.13     | 367.13     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1472     | 0.1472     | 0.1472     |   0.0 |  0.04
Output  | 0.00017636 | 0.00017636 | 0.00017636 |   0.0 |  0.00
Modify  | 0.69059    | 0.69059    | 0.69059    |   0.0 |  0.19
Other   |            | 0.09625    |            |       |  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:      342416.0 ave      342416 max      342416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342416
Ave neighs/atom = 85.604000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.372482890702, Press = 0.0184405885942116
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17496.672   -17496.672   -17644.057   -17644.057    285.12521    285.12521    43986.803    43986.803    3643.1858    3643.1858 
   23000   -17488.939   -17488.939   -17643.455   -17643.455    298.92015    298.92015    44053.694    44053.694    1029.9233    1029.9233 
Loop time of 377.714 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.920 hours/ns, 2.648 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.75     | 376.75     | 376.75     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14731    | 0.14731    | 0.14731    |   0.0 |  0.04
Output  | 0.00022144 | 0.00022144 | 0.00022144 |   0.0 |  0.00
Modify  | 0.71207    | 0.71207    | 0.71207    |   0.0 |  0.19
Other   |            | 0.1002     |            |       |  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:      342482.0 ave      342482 max      342482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342482
Ave neighs/atom = 85.620500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.496033695917, Press = 1.74650594567411
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17488.939   -17488.939   -17643.455   -17643.455    298.92015    298.92015    44053.694    44053.694    1029.9233    1029.9233 
   24000    -17494.29    -17494.29   -17646.409   -17646.409    294.28553    294.28553    44074.075    44074.075   -130.23169   -130.23169 
Loop time of 398.738 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.217 ns/day, 110.761 hours/ns, 2.508 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    | 397.71     | 397.71     | 397.71     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1545     | 0.1545     | 0.1545     |   0.0 |  0.04
Output  | 0.00024654 | 0.00024654 | 0.00024654 |   0.0 |  0.00
Modify  | 0.77439    | 0.77439    | 0.77439    |   0.0 |  0.19
Other   |            | 0.1035     |            |       |  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:      342356.0 ave      342356 max      342356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342356
Ave neighs/atom = 85.589000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.583587384126, Press = 1.22844384578663
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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    -17494.29    -17494.29   -17646.409   -17646.409    294.28553    294.28553    44074.075    44074.075   -130.23169   -130.23169 
   25000   -17498.479   -17498.479   -17649.396   -17649.396    291.95851    291.95851    44086.938    44086.938   -893.16394   -893.16394 
Loop time of 405.451 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.625 hours/ns, 2.466 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    | 404.39     | 404.39     | 404.39     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15791    | 0.15791    | 0.15791    |   0.0 |  0.04
Output  | 0.00022863 | 0.00022863 | 0.00022863 |   0.0 |  0.00
Modify  | 0.79282    | 0.79282    | 0.79282    |   0.0 |  0.20
Other   |            | 0.1047     |            |       |  0.03

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

Total # of neighbors = 342374
Ave neighs/atom = 85.593500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.591287723314, Press = 0.555693417500624
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17498.479   -17498.479   -17649.396   -17649.396    291.95851    291.95851    44086.938    44086.938   -893.16394   -893.16394 
   26000   -17493.367   -17493.367   -17644.558   -17644.558     292.4887     292.4887    44115.306    44115.306    -1692.552    -1692.552 
Loop time of 419.882 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.634 hours/ns, 2.382 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    | 418.78     | 418.78     | 418.78     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16277    | 0.16277    | 0.16277    |   0.0 |  0.04
Output  | 0.00023279 | 0.00023279 | 0.00023279 |   0.0 |  0.00
Modify  | 0.83397    | 0.83397    | 0.83397    |   0.0 |  0.20
Other   |            | 0.1064     |            |       |  0.03

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

Total # of neighbors = 342398
Ave neighs/atom = 85.599500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.588528531122, Press = -1.27782630593353
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17493.367   -17493.367   -17644.558   -17644.558     292.4887     292.4887    44115.306    44115.306    -1692.552    -1692.552 
   27000   -17494.775   -17494.775   -17645.552   -17645.552    291.68946    291.68946     44090.15     44090.15   -756.22225   -756.22225 
Loop time of 419.746 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.596 hours/ns, 2.382 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    | 418.64     | 418.64     | 418.64     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16128    | 0.16128    | 0.16128    |   0.0 |  0.04
Output  | 0.00027348 | 0.00027348 | 0.00027348 |   0.0 |  0.00
Modify  | 0.83995    | 0.83995    | 0.83995    |   0.0 |  0.20
Other   |            | 0.1067     |            |       |  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:      342226.0 ave      342226 max      342226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342226
Ave neighs/atom = 85.556500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.616230364228, Press = -3.87211113119596
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17494.775   -17494.775   -17645.552   -17645.552    291.68946    291.68946     44090.15     44090.15   -756.22225   -756.22225 
   28000   -17494.941   -17494.941   -17647.097   -17647.097     294.3552     294.3552    44035.943    44035.943    1387.3915    1387.3915 
Loop time of 402.023 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.215 ns/day, 111.673 hours/ns, 2.487 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    | 400.99     | 400.99     | 400.99     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15643    | 0.15643    | 0.15643    |   0.0 |  0.04
Output  | 0.00018114 | 0.00018114 | 0.00018114 |   0.0 |  0.00
Modify  | 0.77752    | 0.77752    | 0.77752    |   0.0 |  0.19
Other   |            | 0.1035     |            |       |  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:      342182.0 ave      342182 max      342182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342182
Ave neighs/atom = 85.545500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.727898086795, Press = -1.65105926910229
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17494.941   -17494.941   -17647.097   -17647.097     294.3552     294.3552    44035.943    44035.943    1387.3915    1387.3915 
   29000   -17498.116   -17498.116   -17649.121   -17649.121     292.1308     292.1308    44022.687    44022.687    1697.4215    1697.4215 
Loop time of 414.108 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 115.030 hours/ns, 2.415 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    | 413.03     | 413.03     | 413.03     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15992    | 0.15992    | 0.15992    |   0.0 |  0.04
Output  | 0.00021482 | 0.00021482 | 0.00021482 |   0.0 |  0.00
Modify  | 0.814      | 0.814      | 0.814      |   0.0 |  0.20
Other   |            | 0.1057     |            |       |  0.03

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

Total # of neighbors = 342348
Ave neighs/atom = 85.587000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.723281529142, Press = 0.569810265553525
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17498.116   -17498.116   -17649.121   -17649.121     292.1308     292.1308    44022.687    44022.687    1697.4215    1697.4215 
   30000   -17493.344   -17493.344   -17646.538   -17646.538    296.36319    296.36319    44049.202    44049.202    941.67401    941.67401 
Loop time of 420.132 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.703 hours/ns, 2.380 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    | 419.03     | 419.03     | 419.03     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16288    | 0.16288    | 0.16288    |   0.0 |  0.04
Output  | 0.00024264 | 0.00024264 | 0.00024264 |   0.0 |  0.00
Modify  | 0.83306    | 0.83306    | 0.83306    |   0.0 |  0.20
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:      342502.0 ave      342502 max      342502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342502
Ave neighs/atom = 85.625500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.742754399228, Press = 1.55191299512436
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17493.344   -17493.344   -17646.538   -17646.538    296.36319    296.36319    44049.202    44049.202    941.67401    941.67401 
   31000   -17497.201   -17497.201   -17647.549   -17647.549    290.85801    290.85801    44072.243    44072.243   -142.89071   -142.89071 
Loop time of 420.496 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 116.804 hours/ns, 2.378 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    | 419.4      | 419.4      | 419.4      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16158    | 0.16158    | 0.16158    |   0.0 |  0.04
Output  | 0.00025223 | 0.00025223 | 0.00025223 |   0.0 |  0.00
Modify  | 0.83007    | 0.83007    | 0.83007    |   0.0 |  0.20
Other   |            | 0.1059     |            |       |  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:      342316.0 ave      342316 max      342316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342316
Ave neighs/atom = 85.579000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.789166439422, Press = 1.47555817758788
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17497.201   -17497.201   -17647.549   -17647.549    290.85801    290.85801    44072.243    44072.243   -142.89071   -142.89071 
   32000   -17489.451   -17489.451   -17642.319   -17642.319    295.73414    295.73414    44087.873    44087.873   -317.13504   -317.13504 
Loop time of 376.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.484 hours/ns, 2.659 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    | 375.18     | 375.18     | 375.18     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14784    | 0.14784    | 0.14784    |   0.0 |  0.04
Output  | 0.00017616 | 0.00017616 | 0.00017616 |   0.0 |  0.00
Modify  | 0.71274    | 0.71274    | 0.71274    |   0.0 |  0.19
Other   |            | 0.09786    |            |       |  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:      342342.0 ave      342342 max      342342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342342
Ave neighs/atom = 85.585500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.874352656988, Press = 0.716845086007958
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17489.451   -17489.451   -17642.319   -17642.319    295.73414    295.73414    44087.873    44087.873   -317.13504   -317.13504 
   33000   -17496.766   -17496.766   -17649.635   -17649.635    295.73535    295.73535    44075.355    44075.355   -409.63347   -409.63347 
Loop time of 398.546 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.217 ns/day, 110.707 hours/ns, 2.509 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    | 397.52     | 397.52     | 397.52     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15497    | 0.15497    | 0.15497    |   0.0 |  0.04
Output  | 0.0001804  | 0.0001804  | 0.0001804  |   0.0 |  0.00
Modify  | 0.76589    | 0.76589    | 0.76589    |   0.0 |  0.19
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:      342200.0 ave      342200 max      342200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342200
Ave neighs/atom = 85.550000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.903391679061, Press = 0.192078670721381
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17496.766   -17496.766   -17649.635   -17649.635    295.73535    295.73535    44075.355    44075.355   -409.63347   -409.63347 
   34000   -17496.314   -17496.314    -17645.22    -17645.22    288.06977    288.06977    44069.818    44069.818    81.081753    81.081753 
Loop time of 395.711 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 109.920 hours/ns, 2.527 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    | 394.69     | 394.69     | 394.69     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1551     | 0.1551     | 0.1551     |   0.0 |  0.04
Output  | 0.00017787 | 0.00017787 | 0.00017787 |   0.0 |  0.00
Modify  | 0.76714    | 0.76714    | 0.76714    |   0.0 |  0.19
Other   |            | 0.1025     |            |       |  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:      342386.0 ave      342386 max      342386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342386
Ave neighs/atom = 85.596500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.925268473112, Press = -0.0227437599669136
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17496.314   -17496.314    -17645.22    -17645.22    288.06977    288.06977    44069.818    44069.818    81.081753    81.081753 
   35000   -17498.678   -17498.678   -17648.708   -17648.708    290.24243    290.24243    44063.228    44063.228    94.544595    94.544595 
Loop time of 396.208 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 110.058 hours/ns, 2.524 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    | 395.21     | 395.21     | 395.21     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15125    | 0.15125    | 0.15125    |   0.0 |  0.04
Output  | 0.0001769  | 0.0001769  | 0.0001769  |   0.0 |  0.00
Modify  | 0.74967    | 0.74967    | 0.74967    |   0.0 |  0.19
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:      342302.0 ave      342302 max      342302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342302
Ave neighs/atom = 85.575500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.920929187837, Press = 0.0708906958219475
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17498.678   -17498.678   -17648.708   -17648.708    290.24243    290.24243    44063.228    44063.228    94.544595    94.544595 
   36000   -17494.839   -17494.839   -17647.247   -17647.247    294.84343    294.84343    44068.597    44068.597    68.525594    68.525594 
Loop time of 417.709 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 116.030 hours/ns, 2.394 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    | 416.61     | 416.61     | 416.61     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15912    | 0.15912    | 0.15912    |   0.0 |  0.04
Output  | 0.00027683 | 0.00027683 | 0.00027683 |   0.0 |  0.00
Modify  | 0.82918    | 0.82918    | 0.82918    |   0.0 |  0.20
Other   |            | 0.1067     |            |       |  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:      342464.0 ave      342464 max      342464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342464
Ave neighs/atom = 85.616000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.934146307281, Press = 0.31735158637067
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17494.839   -17494.839   -17647.247   -17647.247    294.84343    294.84343    44068.597    44068.597    68.525594    68.525594 
   37000   -17495.547   -17495.547   -17648.964   -17648.964    296.79583    296.79583    44072.047    44072.047   -188.27111   -188.27111 
Loop time of 383.946 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 382.97     | 382.97     | 382.97     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14823    | 0.14823    | 0.14823    |   0.0 |  0.04
Output  | 0.00017911 | 0.00017911 | 0.00017911 |   0.0 |  0.00
Modify  | 0.73208    | 0.73208    | 0.73208    |   0.0 |  0.19
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:      342464.0 ave      342464 max      342464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342464
Ave neighs/atom = 85.616000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.93119584498, Press = 0.589998244356556
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17495.547   -17495.547   -17648.964   -17648.964    296.79583    296.79583    44072.047    44072.047   -188.27111   -188.27111 
   38000   -17501.019   -17501.019   -17651.354   -17651.354    290.83388    290.83388    44083.192    44083.192   -962.33098   -962.33098 
Loop time of 378.734 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.204 hours/ns, 2.640 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    | 377.77     | 377.77     | 377.77     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14805    | 0.14805    | 0.14805    |   0.0 |  0.04
Output  | 0.00018136 | 0.00018136 | 0.00018136 |   0.0 |  0.00
Modify  | 0.71584    | 0.71584    | 0.71584    |   0.0 |  0.19
Other   |            | 0.09785    |            |       |  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:      342474.0 ave      342474 max      342474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342474
Ave neighs/atom = 85.618500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.906362758327, Press = 0.401573258941076
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17501.019   -17501.019   -17651.354   -17651.354    290.83388    290.83388    44083.192    44083.192   -962.33098   -962.33098 
   39000   -17491.649   -17491.649   -17646.523   -17646.523    299.61523    299.61523    44115.733    44115.733    -1786.813    -1786.813 
Loop time of 423.485 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.635 hours/ns, 2.361 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    | 422.38     | 422.38     | 422.38     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16092    | 0.16092    | 0.16092    |   0.0 |  0.04
Output  | 0.00022966 | 0.00022966 | 0.00022966 |   0.0 |  0.00
Modify  | 0.83993    | 0.83993    | 0.83993    |   0.0 |  0.20
Other   |            | 0.1072     |            |       |  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:      342516.0 ave      342516 max      342516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342516
Ave neighs/atom = 85.629000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.878453951229, Press = -0.620003429186396
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17491.649   -17491.649   -17646.523   -17646.523    299.61523    299.61523    44115.733    44115.733    -1786.813    -1786.813 
   40000   -17497.545   -17497.545   -17648.743   -17648.743    292.50231    292.50231    44088.129    44088.129   -905.57234   -905.57234 
Loop time of 390.317 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.422 hours/ns, 2.562 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    | 389.32     | 389.32     | 389.32     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14914    | 0.14914    | 0.14914    |   0.0 |  0.04
Output  | 0.00024869 | 0.00024869 | 0.00024869 |   0.0 |  0.00
Modify  | 0.74372    | 0.74372    | 0.74372    |   0.0 |  0.19
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:      342226.0 ave      342226 max      342226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342226
Ave neighs/atom = 85.556500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.900374441302, Press = -1.83724928070919
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   -17497.545   -17497.545   -17648.743   -17648.743    292.50231    292.50231    44088.129    44088.129   -905.57234   -905.57234 
   41000    -17489.75    -17489.75   -17645.202   -17645.202    300.73129    300.73129    44050.665    44050.665    995.80452    995.80452 
Loop time of 413.57 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.881 hours/ns, 2.418 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    | 412.49     | 412.49     | 412.49     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15873    | 0.15873    | 0.15873    |   0.0 |  0.04
Output  | 0.00025871 | 0.00025871 | 0.00025871 |   0.0 |  0.00
Modify  | 0.81591    | 0.81591    | 0.81591    |   0.0 |  0.20
Other   |            | 0.1065     |            |       |  0.03

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

Total # of neighbors = 342392
Ave neighs/atom = 85.598000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.932684551026, Press = -1.39707746746992
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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    -17489.75    -17489.75   -17645.202   -17645.202    300.73129    300.73129    44050.665    44050.665    995.80452    995.80452 
   42000   -17495.527   -17495.527   -17646.528   -17646.528    292.12215    292.12215     44048.47     44048.47    950.28889    950.28889 
Loop time of 403.868 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 112.186 hours/ns, 2.476 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    | 402.81     | 402.81     | 402.81     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15637    | 0.15637    | 0.15637    |   0.0 |  0.04
Output  | 0.00017849 | 0.00017849 | 0.00017849 |   0.0 |  0.00
Modify  | 0.79228    | 0.79228    | 0.79228    |   0.0 |  0.20
Other   |            | 0.1047     |            |       |  0.03

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0