# 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 2.8510001525282864*${_u_distance}
variable latticeconst_converted equal 2.8510001525282864*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85100015252829
Lattice spacing in x,y,z = 2.8510002 2.8510002 2.8510002
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 (28.510002 28.510002 28.510002)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.510002 28.510002 28.510002)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_AsadiZaeemNouranian_2015_Fe__MO_492310898779_001
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8514.5876   -8514.5876   -8579.9993   -8579.9993       253.15       253.15    23173.505    23173.505    3014.9828    3014.9828 
    1000   -8447.2132   -8447.2132   -8510.1471   -8510.1471    243.56076    243.56076    23383.307    23383.307   -2438.0871   -2438.0871 
Loop time of 154.82 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.558 ns/day, 43.006 hours/ns, 6.459 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 154.3      | 154.3      | 154.3      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099817   | 0.099817   | 0.099817   |   0.0 |  0.06
Output  | 0.00019756 | 0.00019756 | 0.00019756 |   0.0 |  0.00
Modify  | 0.36293    | 0.36293    | 0.36293    |   0.0 |  0.23
Other   |            | 0.06133    |            |       |  0.04

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

Total # of neighbors = 128000
Ave neighs/atom = 64.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8447.2132   -8447.2132   -8510.1471   -8510.1471    243.56076    243.56076    23383.307    23383.307   -2438.0871   -2438.0871 
    2000   -8446.3264   -8446.3264   -8510.3472   -8510.3472    247.76709    247.76709    23349.482    23349.482    8.4062393    8.4062393 
Loop time of 158.043 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.547 ns/day, 43.901 hours/ns, 6.327 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    | 157.53     | 157.53     | 157.53     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098392   | 0.098392   | 0.098392   |   0.0 |  0.06
Output  | 0.00022142 | 0.00022142 | 0.00022142 |   0.0 |  0.00
Modify  | 0.35478    | 0.35478    | 0.35478    |   0.0 |  0.22
Other   |            | 0.06001    |            |       |  0.04

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

Total # of neighbors = 128244
Ave neighs/atom = 64.122000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8446.3264   -8446.3264   -8510.3472   -8510.3472    247.76709    247.76709    23349.482    23349.482    8.4062393    8.4062393 
    3000   -8448.2989   -8448.2989   -8516.6515   -8516.6515    264.53178    264.53178    23336.461    23336.461    229.56391    229.56391 
Loop time of 170.053 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.508 ns/day, 47.237 hours/ns, 5.881 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.49     | 169.49     | 169.49     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10489    | 0.10489    | 0.10489    |   0.0 |  0.06
Output  | 0.00022953 | 0.00022953 | 0.00022953 |   0.0 |  0.00
Modify  | 0.39755    | 0.39755    | 0.39755    |   0.0 |  0.23
Other   |            | 0.0639     |            |       |  0.04

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

Total # of neighbors = 128180
Ave neighs/atom = 64.090000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8448.2989   -8448.2989   -8516.6515   -8516.6515    264.53178    264.53178    23336.461    23336.461    229.56391    229.56391 
    4000   -8445.9338   -8445.9338   -8508.6279   -8508.6279    242.63237    242.63237    23365.706    23365.706   -943.32286   -943.32286 
Loop time of 176.986 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.488 ns/day, 49.163 hours/ns, 5.650 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    | 176.39     | 176.39     | 176.39     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10904    | 0.10904    | 0.10904    |   0.0 |  0.06
Output  | 0.00022044 | 0.00022044 | 0.00022044 |   0.0 |  0.00
Modify  | 0.41959    | 0.41959    | 0.41959    |   0.0 |  0.24
Other   |            | 0.06543    |            |       |  0.04

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

Total # of neighbors = 128174
Ave neighs/atom = 64.087000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8445.9338   -8445.9338   -8508.6279   -8508.6279    242.63237    242.63237    23365.706    23365.706   -943.32286   -943.32286 
    5000   -8448.1648   -8448.1648   -8516.0272   -8516.0272    262.63458    262.63458    23331.545    23331.545    779.04601    779.04601 
Loop time of 177.252 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.487 ns/day, 49.237 hours/ns, 5.642 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    | 176.66     | 176.66     | 176.66     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10841    | 0.10841    | 0.10841    |   0.0 |  0.06
Output  | 0.00015444 | 0.00015444 | 0.00015444 |   0.0 |  0.00
Modify  | 0.41877    | 0.41877    | 0.41877    |   0.0 |  0.24
Other   |            | 0.06534    |            |       |  0.04

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

Total # of neighbors = 128214
Ave neighs/atom = 64.107000
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 = 249.841198005025, Press = -423.080651331402
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8448.1648   -8448.1648   -8516.0272   -8516.0272    262.63458    262.63458    23331.545    23331.545    779.04601    779.04601 
    6000   -8446.3888   -8446.3888   -8510.7937   -8510.7937    249.25382    249.25382    23343.394    23343.394     649.4181     649.4181 
Loop time of 170.51 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.507 ns/day, 47.364 hours/ns, 5.865 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.92     | 169.92     | 169.92     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10583    | 0.10583    | 0.10583    |   0.0 |  0.06
Output  | 0.00015352 | 0.00015352 | 0.00015352 |   0.0 |  0.00
Modify  | 0.41707    | 0.41707    | 0.41707    |   0.0 |  0.24
Other   |            | 0.06372    |            |       |  0.04

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

Total # of neighbors = 128138
Ave neighs/atom = 64.069000
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 = 252.543117046991, Press = 26.610625465754
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8446.3888   -8446.3888   -8510.7937   -8510.7937    249.25382    249.25382    23343.394    23343.394     649.4181     649.4181 
    7000   -8447.7268   -8447.7268   -8514.9729   -8514.9729    260.24925    260.24925    23388.381    23388.381   -3113.7836   -3113.7836 
Loop time of 151.451 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.070 hours/ns, 6.603 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    | 150.95     | 150.95     | 150.95     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09424    | 0.09424    | 0.09424    |   0.0 |  0.06
Output  | 0.0001574  | 0.0001574  | 0.0001574  |   0.0 |  0.00
Modify  | 0.35142    | 0.35142    | 0.35142    |   0.0 |  0.23
Other   |            | 0.05995    |            |       |  0.04

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

Total # of neighbors = 128208
Ave neighs/atom = 64.104000
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 = 251.80435985034, Press = -48.7385087438835
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8447.7268   -8447.7268   -8514.9729   -8514.9729    260.24925    260.24925    23388.381    23388.381   -3113.7836   -3113.7836 
    8000   -8447.9896   -8447.9896   -8512.2903   -8512.2903     248.8502     248.8502    23312.291    23312.291    2487.7611    2487.7611 
Loop time of 151.498 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.083 hours/ns, 6.601 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.99     | 150.99     | 150.99     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094222   | 0.094222   | 0.094222   |   0.0 |  0.06
Output  | 0.00015314 | 0.00015314 | 0.00015314 |   0.0 |  0.00
Modify  | 0.35227    | 0.35227    | 0.35227    |   0.0 |  0.23
Other   |            | 0.05985    |            |       |  0.04

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

Total # of neighbors = 128118
Ave neighs/atom = 64.059000
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 = 251.898549376794, Press = 2.56818676420595
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8447.9896   -8447.9896   -8512.2903   -8512.2903     248.8502     248.8502    23312.291    23312.291    2487.7611    2487.7611 
    9000    -8447.102    -8447.102   -8510.2425   -8510.2425    244.36043    244.36043    23366.903    23366.903   -1204.4998   -1204.4998 
Loop time of 152.049 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.236 hours/ns, 6.577 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    | 151.54     | 151.54     | 151.54     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095494   | 0.095494   | 0.095494   |   0.0 |  0.06
Output  | 0.00015447 | 0.00015447 | 0.00015447 |   0.0 |  0.00
Modify  | 0.35199    | 0.35199    | 0.35199    |   0.0 |  0.23
Other   |            | 0.05866    |            |       |  0.04

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

Total # of neighbors = 128154
Ave neighs/atom = 64.077000
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 = 251.935756760467, Press = -3.67984074778562
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000    -8447.102    -8447.102   -8510.2425   -8510.2425    244.36043    244.36043    23366.903    23366.903   -1204.4998   -1204.4998 
   10000   -8443.5327   -8443.5327   -8508.9612   -8508.9612    253.21491    253.21491    23340.537    23340.537    991.73793    991.73793 
Loop time of 152.232 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.287 hours/ns, 6.569 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    | 151.73     | 151.73     | 151.73     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095945   | 0.095945   | 0.095945   |   0.0 |  0.06
Output  | 0.00018514 | 0.00018514 | 0.00018514 |   0.0 |  0.00
Modify  | 0.35185    | 0.35185    | 0.35185    |   0.0 |  0.23
Other   |            | 0.05773    |            |       |  0.04

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

Total # of neighbors = 128194
Ave neighs/atom = 64.097000
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 = 252.744343568438, Press = -7.9541040364264
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8443.5327   -8443.5327   -8508.9612   -8508.9612    253.21491    253.21491    23340.537    23340.537    991.73793    991.73793 
   11000   -8446.2205   -8446.2205   -8512.2868   -8512.2868    255.68334    255.68334    23359.819    23359.819   -885.83927   -885.83927 
Loop time of 153.629 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.562 ns/day, 42.675 hours/ns, 6.509 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    | 153.12     | 153.12     | 153.12     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096446   | 0.096446   | 0.096446   |   0.0 |  0.06
Output  | 0.00015467 | 0.00015467 | 0.00015467 |   0.0 |  0.00
Modify  | 0.35515    | 0.35515    | 0.35515    |   0.0 |  0.23
Other   |            | 0.05825    |            |       |  0.04

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

Total # of neighbors = 128232
Ave neighs/atom = 64.116000
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 = 252.909867099827, Press = 2.08599418612328
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8446.2205   -8446.2205   -8512.2868   -8512.2868    255.68334    255.68334    23359.819    23359.819   -885.83927   -885.83927 
   12000   -8448.8488   -8448.8488    -8513.857    -8513.857    251.58842    251.58842    23355.917    23355.917   -880.47902   -880.47902 
Loop time of 152.125 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.257 hours/ns, 6.574 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    | 151.62     | 151.62     | 151.62     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095618   | 0.095618   | 0.095618   |   0.0 |  0.06
Output  | 0.00015557 | 0.00015557 | 0.00015557 |   0.0 |  0.00
Modify  | 0.35322    | 0.35322    | 0.35322    |   0.0 |  0.23
Other   |            | 0.05785    |            |       |  0.04

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

Total # of neighbors = 128178
Ave neighs/atom = 64.089000
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 = 252.896802143772, Press = -15.4387325920073
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8448.8488   -8448.8488    -8513.857    -8513.857    251.58842    251.58842    23355.917    23355.917   -880.47902   -880.47902 
   13000   -8445.7442   -8445.7442   -8513.2636   -8513.2636    261.30679    261.30679    23323.365    23323.365     1626.235     1626.235 
Loop time of 152.248 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.291 hours/ns, 6.568 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    | 151.74     | 151.74     | 151.74     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094986   | 0.094986   | 0.094986   |   0.0 |  0.06
Output  | 0.0001929  | 0.0001929  | 0.0001929  |   0.0 |  0.00
Modify  | 0.35211    | 0.35211    | 0.35211    |   0.0 |  0.23
Other   |            | 0.0581     |            |       |  0.04

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

Total # of neighbors = 128142
Ave neighs/atom = 64.071000
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 = 252.709716237039, Press = 6.03911637320083
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8445.7442   -8445.7442   -8513.2636   -8513.2636    261.30679    261.30679    23323.365    23323.365     1626.235     1626.235 
   14000   -8450.5128   -8450.5128   -8514.3698   -8514.3698    247.13304    247.13304    23367.072    23367.072   -1698.7715   -1698.7715 
Loop time of 151.609 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.113 hours/ns, 6.596 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    | 151.1      | 151.1      | 151.1      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094301   | 0.094301   | 0.094301   |   0.0 |  0.06
Output  | 0.000154   | 0.000154   | 0.000154   |   0.0 |  0.00
Modify  | 0.35075    | 0.35075    | 0.35075    |   0.0 |  0.23
Other   |            | 0.05897    |            |       |  0.04

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

Total # of neighbors = 128172
Ave neighs/atom = 64.086000
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 = 252.566607772691, Press = -4.45854130269051
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8450.5128   -8450.5128   -8514.3698   -8514.3698    247.13304    247.13304    23367.072    23367.072   -1698.7715   -1698.7715 
   15000   -8447.2092   -8447.2092   -8511.2431   -8511.2431    247.81779    247.81779    23326.811    23326.811    1519.1225    1519.1225 
Loop time of 151.576 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.104 hours/ns, 6.597 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    | 151.07     | 151.07     | 151.07     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094502   | 0.094502   | 0.094502   |   0.0 |  0.06
Output  | 0.00015333 | 0.00015333 | 0.00015333 |   0.0 |  0.00
Modify  | 0.34984    | 0.34984    | 0.34984    |   0.0 |  0.23
Other   |            | 0.05872    |            |       |  0.04

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

Total # of neighbors = 128142
Ave neighs/atom = 64.071000
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 = 252.532840350291, Press = -2.11970448559099
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8447.2092   -8447.2092   -8511.2431   -8511.2431    247.81779    247.81779    23326.811    23326.811    1519.1225    1519.1225 
   16000   -8444.4606   -8444.4606   -8512.2484   -8512.2484    262.34566    262.34566    23358.739    23358.739   -667.83119   -667.83119 
Loop time of 151.849 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.180 hours/ns, 6.585 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    | 151.34     | 151.34     | 151.34     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095481   | 0.095481   | 0.095481   |   0.0 |  0.06
Output  | 0.00019126 | 0.00019126 | 0.00019126 |   0.0 |  0.00
Modify  | 0.35167    | 0.35167    | 0.35167    |   0.0 |  0.23
Other   |            | 0.05907    |            |       |  0.04

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

Total # of neighbors = 128242
Ave neighs/atom = 64.121000
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 = 252.612870862072, Press = -0.0701398171658863
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8444.4606   -8444.4606   -8512.2484   -8512.2484    262.34566    262.34566    23358.739    23358.739   -667.83119   -667.83119 
   17000    -8449.537    -8449.537   -8512.9099   -8512.9099     245.2599     245.2599    23338.531    23338.531    469.44086    469.44086 
Loop time of 153.09 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.525 hours/ns, 6.532 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    | 152.58     | 152.58     | 152.58     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096094   | 0.096094   | 0.096094   |   0.0 |  0.06
Output  | 0.00015696 | 0.00015696 | 0.00015696 |   0.0 |  0.00
Modify  | 0.35674    | 0.35674    | 0.35674    |   0.0 |  0.23
Other   |            | 0.05801    |            |       |  0.04

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

Total # of neighbors = 128146
Ave neighs/atom = 64.073000
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 = 252.682651610088, Press = -3.86955077602793
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000    -8449.537    -8449.537   -8512.9099   -8512.9099     245.2599     245.2599    23338.531    23338.531    469.44086    469.44086 
   18000   -8446.3441   -8446.3441   -8511.4598   -8511.4598    252.00447    252.00447    23345.775    23345.775    204.64164    204.64164 
Loop time of 152.625 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.396 hours/ns, 6.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    | 152.12     | 152.12     | 152.12     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096508   | 0.096508   | 0.096508   |   0.0 |  0.06
Output  | 0.00020063 | 0.00020063 | 0.00020063 |   0.0 |  0.00
Modify  | 0.35352    | 0.35352    | 0.35352    |   0.0 |  0.23
Other   |            | 0.05769    |            |       |  0.04

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

Total # of neighbors = 128158
Ave neighs/atom = 64.079000
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 = 252.616485578818, Press = 3.17058318209157
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8446.3441   -8446.3441   -8511.4598   -8511.4598    252.00447    252.00447    23345.775    23345.775    204.64164    204.64164 
   19000   -8445.2267   -8445.2267   -8512.0242   -8512.0242      258.513      258.513    23383.923    23383.923    -2349.042    -2349.042 
Loop time of 152.323 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.312 hours/ns, 6.565 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    | 151.82     | 151.82     | 151.82     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096233   | 0.096233   | 0.096233   |   0.0 |  0.06
Output  | 0.00015365 | 0.00015365 | 0.00015365 |   0.0 |  0.00
Modify  | 0.35311    | 0.35311    | 0.35311    |   0.0 |  0.23
Other   |            | 0.05772    |            |       |  0.04

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

Total # of neighbors = 128192
Ave neighs/atom = 64.096000
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 = 252.805804219848, Press = -6.78083553890532
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8445.2267   -8445.2267   -8512.0242   -8512.0242      258.513      258.513    23383.923    23383.923    -2349.042    -2349.042 
   20000   -8446.3428   -8446.3428   -8514.1148   -8514.1148    262.28467    262.28467    23322.136    23322.136    1660.1406    1660.1406 
Loop time of 153.521 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.645 hours/ns, 6.514 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    | 153.01     | 153.01     | 153.01     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097013   | 0.097013   | 0.097013   |   0.0 |  0.06
Output  | 0.00016115 | 0.00016115 | 0.00016115 |   0.0 |  0.00
Modify  | 0.3572     | 0.3572     | 0.3572     |   0.0 |  0.23
Other   |            | 0.05759    |            |       |  0.04

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

Total # of neighbors = 128114
Ave neighs/atom = 64.057000
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 = 252.852565763269, Press = 0.528528105712918
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8446.3428   -8446.3428   -8514.1148   -8514.1148    262.28467    262.28467    23322.136    23322.136    1660.1406    1660.1406 
   21000   -8446.1569   -8446.1569   -8511.0882   -8511.0882    251.29095    251.29095    23368.069    23368.069   -1264.2392   -1264.2392 
Loop time of 152.332 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.314 hours/ns, 6.565 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    | 151.82     | 151.82     | 151.82     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095805   | 0.095805   | 0.095805   |   0.0 |  0.06
Output  | 0.00015248 | 0.00015248 | 0.00015248 |   0.0 |  0.00
Modify  | 0.35267    | 0.35267    | 0.35267    |   0.0 |  0.23
Other   |            | 0.05897    |            |       |  0.04

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

Total # of neighbors = 128166
Ave neighs/atom = 64.083000
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 = 252.865085508323, Press = -1.07406842493044
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8446.1569   -8446.1569   -8511.0882   -8511.0882    251.29095    251.29095    23368.069    23368.069   -1264.2392   -1264.2392 
   22000   -8449.2424   -8449.2424     -8513.77     -8513.77    249.72836    249.72836    23326.264    23326.264    1243.7409    1243.7409 
Loop time of 151.831 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.175 hours/ns, 6.586 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    | 151.33     | 151.33     | 151.33     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094845   | 0.094845   | 0.094845   |   0.0 |  0.06
Output  | 0.00015229 | 0.00015229 | 0.00015229 |   0.0 |  0.00
Modify  | 0.35149    | 0.35149    | 0.35149    |   0.0 |  0.23
Other   |            | 0.0585     |            |       |  0.04

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

Total # of neighbors = 128170
Ave neighs/atom = 64.085000
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 = 252.738773163361, Press = -2.27050109797172
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8449.2424   -8449.2424     -8513.77     -8513.77    249.72836    249.72836    23326.264    23326.264    1243.7409    1243.7409 
   23000   -8447.5244   -8447.5244   -8513.1763   -8513.1763     254.0795     254.0795    23358.406    23358.406    -893.4712    -893.4712 
Loop time of 151.976 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.216 hours/ns, 6.580 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    | 151.47     | 151.47     | 151.47     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095332   | 0.095332   | 0.095332   |   0.0 |  0.06
Output  | 0.00015287 | 0.00015287 | 0.00015287 |   0.0 |  0.00
Modify  | 0.35371    | 0.35371    | 0.35371    |   0.0 |  0.23
Other   |            | 0.05895    |            |       |  0.04

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

Total # of neighbors = 128146
Ave neighs/atom = 64.073000
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 = 252.841706092042, Press = 0.611476389041507
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8447.5244   -8447.5244   -8513.1763   -8513.1763     254.0795     254.0795    23358.406    23358.406    -893.4712    -893.4712 
   24000   -8444.7824   -8444.7824    -8510.474    -8510.474    254.23335    254.23335    23353.488    23353.488   -75.071656   -75.071656 
Loop time of 152.411 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.336 hours/ns, 6.561 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    | 151.9      | 151.9      | 151.9      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095594   | 0.095594   | 0.095594   |   0.0 |  0.06
Output  | 0.00015461 | 0.00015461 | 0.00015461 |   0.0 |  0.00
Modify  | 0.35327    | 0.35327    | 0.35327    |   0.0 |  0.23
Other   |            | 0.05814    |            |       |  0.04

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

Total # of neighbors = 128156
Ave neighs/atom = 64.078000
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 = 252.912605441446, Press = -3.28488116243926
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8444.7824   -8444.7824    -8510.474    -8510.474    254.23335    254.23335    23353.488    23353.488   -75.071656   -75.071656 
   25000   -8449.9739   -8449.9739   -8513.3512   -8513.3512    245.27662    245.27662    23318.841    23318.841    1790.3297    1790.3297 
Loop time of 152.763 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.434 hours/ns, 6.546 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    | 152.26     | 152.26     | 152.26     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096345   | 0.096345   | 0.096345   |   0.0 |  0.06
Output  | 0.00015246 | 0.00015246 | 0.00015246 |   0.0 |  0.00
Modify  | 0.35263    | 0.35263    | 0.35263    |   0.0 |  0.23
Other   |            | 0.05788    |            |       |  0.04

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

Total # of neighbors = 128228
Ave neighs/atom = 64.114000
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 = 252.905687409714, Press = 0.722509227388376
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8449.9739   -8449.9739   -8513.3512   -8513.3512    245.27662    245.27662    23318.841    23318.841    1790.3297    1790.3297 
   26000   -8445.3318   -8445.3318   -8512.5083   -8512.5083    259.98009    259.98009    23394.734    23394.734   -3166.1442   -3166.1442 
Loop time of 152.156 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.265 hours/ns, 6.572 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    | 151.65     | 151.65     | 151.65     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095719   | 0.095719   | 0.095719   |   0.0 |  0.06
Output  | 0.00015475 | 0.00015475 | 0.00015475 |   0.0 |  0.00
Modify  | 0.35277    | 0.35277    | 0.35277    |   0.0 |  0.23
Other   |            | 0.05776    |            |       |  0.04

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

Total # of neighbors = 128152
Ave neighs/atom = 64.076000
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 = 252.839621886366, Press = -1.79206039049633
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8445.3318   -8445.3318   -8512.5083   -8512.5083    259.98009    259.98009    23394.734    23394.734   -3166.1442   -3166.1442 
   27000   -8446.9767   -8446.9767   -8512.7392   -8512.7392    254.50772    254.50772    23306.664    23306.664    2753.6051    2753.6051 
Loop time of 152.821 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.450 hours/ns, 6.544 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    | 152.31     | 152.31     | 152.31     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096579   | 0.096579   | 0.096579   |   0.0 |  0.06
Output  | 0.00018881 | 0.00018881 | 0.00018881 |   0.0 |  0.00
Modify  | 0.35336    | 0.35336    | 0.35336    |   0.0 |  0.23
Other   |            | 0.0577     |            |       |  0.04

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

Total # of neighbors = 128170
Ave neighs/atom = 64.085000
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 = 252.845636478356, Press = -2.21695320760017
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8446.9767   -8446.9767   -8512.7392   -8512.7392    254.50772    254.50772    23306.664    23306.664    2753.6051    2753.6051 
   28000   -8450.3046   -8450.3046   -8514.7338   -8514.7338    249.34774    249.34774    23348.738    23348.738   -514.11115   -514.11115 
Loop time of 152.639 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.400 hours/ns, 6.551 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    | 152.13     | 152.13     | 152.13     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095655   | 0.095655   | 0.095655   |   0.0 |  0.06
Output  | 0.00019444 | 0.00019444 | 0.00019444 |   0.0 |  0.00
Modify  | 0.35247    | 0.35247    | 0.35247    |   0.0 |  0.23
Other   |            | 0.05791    |            |       |  0.04

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

Total # of neighbors = 128188
Ave neighs/atom = 64.094000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.85985803808, Press = 0.938770905149094
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8450.3046   -8450.3046   -8514.7338   -8514.7338    249.34774    249.34774    23348.738    23348.738   -514.11115   -514.11115 
   29000   -8446.0891   -8446.0891   -8511.0595   -8511.0595    251.44221    251.44221    23353.852    23353.852   -289.06488   -289.06488 
Loop time of 152.524 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.368 hours/ns, 6.556 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    | 152.02     | 152.02     | 152.02     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096079   | 0.096079   | 0.096079   |   0.0 |  0.06
Output  | 0.00015575 | 0.00015575 | 0.00015575 |   0.0 |  0.00
Modify  | 0.35353    | 0.35353    | 0.35353    |   0.0 |  0.23
Other   |            | 0.05784    |            |       |  0.04

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

Total # of neighbors = 128140
Ave neighs/atom = 64.070000
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 = 252.802001313244, Press = -1.97409698119173
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8446.0891   -8446.0891   -8511.0595   -8511.0595    251.44221    251.44221    23353.852    23353.852   -289.06488   -289.06488 
   30000   -8449.7728   -8449.7728   -8513.2706   -8513.2706    245.74335    245.74335    23330.324    23330.324    1017.5924    1017.5924 
Loop time of 152.294 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.304 hours/ns, 6.566 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.79     | 151.79     | 151.79     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096318   | 0.096318   | 0.096318   |   0.0 |  0.06
Output  | 0.00045707 | 0.00045707 | 0.00045707 |   0.0 |  0.00
Modify  | 0.35239    | 0.35239    | 0.35239    |   0.0 |  0.23
Other   |            | 0.05772    |            |       |  0.04

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

Total # of neighbors = 128178
Ave neighs/atom = 64.089000
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 = 252.81752005955, Press = -0.193825340710319
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8449.7728   -8449.7728   -8513.2706   -8513.2706    245.74335    245.74335    23330.324    23330.324    1017.5924    1017.5924 
   31000   -8447.2497   -8447.2497   -8511.7759   -8511.7759    249.72291    249.72291    23376.909    23376.909   -1992.6709   -1992.6709 
Loop time of 152.353 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.320 hours/ns, 6.564 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    | 151.84     | 151.84     | 151.84     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096518   | 0.096518   | 0.096518   |   0.0 |  0.06
Output  | 0.0001547  | 0.0001547  | 0.0001547  |   0.0 |  0.00
Modify  | 0.35431    | 0.35431    | 0.35431    |   0.0 |  0.23
Other   |            | 0.05788    |            |       |  0.04

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

Total # of neighbors = 128200
Ave neighs/atom = 64.100000
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 = 252.728565411202, Press = -1.15530379930424
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8447.2497   -8447.2497   -8511.7759   -8511.7759    249.72291    249.72291    23376.909    23376.909   -1992.6709   -1992.6709 
   32000   -8446.0965   -8446.0965   -8512.5533   -8512.5533    257.19489    257.19489    23299.902    23299.902    3298.2282    3298.2282 
Loop time of 152.379 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.327 hours/ns, 6.563 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    | 151.87     | 151.87     | 151.87     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096224   | 0.096224   | 0.096224   |   0.0 |  0.06
Output  | 0.00015564 | 0.00015564 | 0.00015564 |   0.0 |  0.00
Modify  | 0.35288    | 0.35288    | 0.35288    |   0.0 |  0.23
Other   |            | 0.05827    |            |       |  0.04

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

Total # of neighbors = 128182
Ave neighs/atom = 64.091000
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 = 252.700346001504, Press = -2.17676434942697
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8446.0965   -8446.0965   -8512.5533   -8512.5533    257.19489    257.19489    23299.902    23299.902    3298.2282    3298.2282 
   33000   -8447.5955   -8447.5955   -8513.3375   -8513.3375    254.42862    254.42862    23364.983    23364.983   -1424.3102   -1424.3102 
Loop time of 152.518 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.366 hours/ns, 6.557 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    | 152.01     | 152.01     | 152.01     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097143   | 0.097143   | 0.097143   |   0.0 |  0.06
Output  | 0.00015561 | 0.00015561 | 0.00015561 |   0.0 |  0.00
Modify  | 0.35309    | 0.35309    | 0.35309    |   0.0 |  0.23
Other   |            | 0.05739    |            |       |  0.04

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

Total # of neighbors = 128172
Ave neighs/atom = 64.086000
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 = 252.700420315681, Press = 1.51847679578476
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8447.5955   -8447.5955   -8513.3375   -8513.3375    254.42862    254.42862    23364.983    23364.983   -1424.3102   -1424.3102 
   34000   -8444.7275   -8444.7275   -8512.4685   -8512.4685    262.16491    262.16491    23353.211    23353.211   -408.45404   -408.45404 
Loop time of 152.42 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.339 hours/ns, 6.561 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    | 151.91     | 151.91     | 151.91     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0963     | 0.0963     | 0.0963     |   0.0 |  0.06
Output  | 0.00015569 | 0.00015569 | 0.00015569 |   0.0 |  0.00
Modify  | 0.35238    | 0.35238    | 0.35238    |   0.0 |  0.23
Other   |            | 0.05855    |            |       |  0.04

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

Total # of neighbors = 128146
Ave neighs/atom = 64.073000
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 = 252.70333977562, Press = -2.54259501115303
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8444.7275   -8444.7275   -8512.4685   -8512.4685    262.16491    262.16491    23353.211    23353.211   -408.45404   -408.45404 
   35000   -8449.2608   -8449.2608    -8512.607    -8512.607    245.15622    245.15622    23325.105    23325.105    1409.4067    1409.4067 
Loop time of 152.569 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.380 hours/ns, 6.554 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    | 152.06     | 152.06     | 152.06     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0964     | 0.0964     | 0.0964     |   0.0 |  0.06
Output  | 0.00015664 | 0.00015664 | 0.00015664 |   0.0 |  0.00
Modify  | 0.35351    | 0.35351    | 0.35351    |   0.0 |  0.23
Other   |            | 0.05761    |            |       |  0.04

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

Total # of neighbors = 128168
Ave neighs/atom = 64.084000
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 = 252.739210958103, Press = 0.815838042121198
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8449.2608   -8449.2608    -8512.607    -8512.607    245.15622    245.15622    23325.105    23325.105    1409.4067    1409.4067 
   36000   -8445.9892   -8445.9892   -8512.9002   -8512.9002    258.95258    258.95258    23373.021    23373.021   -1870.0738   -1870.0738 
Loop time of 152.484 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.357 hours/ns, 6.558 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    | 151.98     | 151.98     | 151.98     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096282   | 0.096282   | 0.096282   |   0.0 |  0.06
Output  | 0.00015648 | 0.00015648 | 0.00015648 |   0.0 |  0.00
Modify  | 0.35298    | 0.35298    | 0.35298    |   0.0 |  0.23
Other   |            | 0.05854    |            |       |  0.04

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

Total # of neighbors = 128208
Ave neighs/atom = 64.104000
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 = 252.796203587511, Press = -1.2532084963505
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8445.9892   -8445.9892   -8512.9002   -8512.9002    258.95258    258.95258    23373.021    23373.021   -1870.0738   -1870.0738 
   37000   -8447.7254   -8447.7254   -8514.5213   -8514.5213    258.50693    258.50693    23337.662    23337.662    391.27445    391.27445 
Loop time of 152.52 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.367 hours/ns, 6.557 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    | 152.01     | 152.01     | 152.01     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096055   | 0.096055   | 0.096055   |   0.0 |  0.06
Output  | 0.00018743 | 0.00018743 | 0.00018743 |   0.0 |  0.00
Modify  | 0.35305    | 0.35305    | 0.35305    |   0.0 |  0.23
Other   |            | 0.05799    |            |       |  0.04

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

Total # of neighbors = 128148
Ave neighs/atom = 64.074000
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 = 252.806895808857, Press = -0.779942024726965
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8447.7254   -8447.7254   -8514.5213   -8514.5213    258.50693    258.50693    23337.662    23337.662    391.27445    391.27445 
   38000    -8448.092    -8448.092   -8513.3983   -8513.3983    252.74208    252.74208    23350.319    23350.319   -373.02095   -373.02095 
Loop time of 152.444 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.346 hours/ns, 6.560 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    | 151.94     | 151.94     | 151.94     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096191   | 0.096191   | 0.096191   |   0.0 |  0.06
Output  | 0.0001547  | 0.0001547  | 0.0001547  |   0.0 |  0.00
Modify  | 0.35254    | 0.35254    | 0.35254    |   0.0 |  0.23
Other   |            | 0.05822    |            |       |  0.04

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

Total # of neighbors = 128180
Ave neighs/atom = 64.090000
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 = 252.845494458223, Press = -0.34702453167865
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000    -8448.092    -8448.092   -8513.3983   -8513.3983    252.74208    252.74208    23350.319    23350.319   -373.02095   -373.02095 
   39000   -8443.5453   -8443.5453   -8510.1424   -8510.1424    257.73772    257.73772    23341.966    23341.966    684.79513    684.79513 
Loop time of 152.648 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.402 hours/ns, 6.551 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    | 152.14     | 152.14     | 152.14     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096464   | 0.096464   | 0.096464   |   0.0 |  0.06
Output  | 0.00015589 | 0.00015589 | 0.00015589 |   0.0 |  0.00
Modify  | 0.35289    | 0.35289    | 0.35289    |   0.0 |  0.23
Other   |            | 0.05819    |            |       |  0.04

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

Total # of neighbors = 128162
Ave neighs/atom = 64.081000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.896097494275, Press = -1.19642833931234
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8443.5453   -8443.5453   -8510.1424   -8510.1424    257.73772    257.73772    23341.966    23341.966    684.79513    684.79513 
   40000   -8447.4754   -8447.4754   -8512.4793   -8512.4793    251.57204    251.57204    23345.613    23345.613    42.554244    42.554244 
Loop time of 152.805 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.446 hours/ns, 6.544 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    | 152.3      | 152.3      | 152.3      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095954   | 0.095954   | 0.095954   |   0.0 |  0.06
Output  | 0.00015337 | 0.00015337 | 0.00015337 |   0.0 |  0.00
Modify  | 0.35287    | 0.35287    | 0.35287    |   0.0 |  0.23
Other   |            | 0.05858    |            |       |  0.04

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

Total # of neighbors = 128220
Ave neighs/atom = 64.110000
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 = 252.939956627792, Press = 0.94201169631686
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8447.4754   -8447.4754   -8512.4793   -8512.4793    251.57204    251.57204    23345.613    23345.613    42.554244    42.554244 
   41000   -8444.8666   -8444.8666   -8511.7537   -8511.7537    258.86004    258.86004    23379.401    23379.401   -2056.8096   -2056.8096 
Loop time of 152.133 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.259 hours/ns, 6.573 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    | 151.63     | 151.63     | 151.63     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095028   | 0.095028   | 0.095028   |   0.0 |  0.06
Output  | 0.000191   | 0.000191   | 0.000191   |   0.0 |  0.00
Modify  | 0.35201    | 0.35201    | 0.35201    |   0.0 |  0.23
Other   |            | 0.05953    |            |       |  0.04

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

Total # of neighbors = 128198
Ave neighs/atom = 64.099000
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 = 253.002762711742, Press = -2.77541227221499
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8444.8666   -8444.8666   -8511.7537   -8511.7537    258.86004    258.86004    23379.401    23379.401   -2056.8096   -2056.8096 
   42000   -8451.1424   -8451.1424   -8513.9901   -8513.9901    243.22691    243.22691      23302.9      23302.9    2640.8722    2640.8722 
Loop time of 151.493 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.081 hours/ns, 6.601 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.99     | 150.99     | 150.99     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095155   | 0.095155   | 0.095155   |   0.0 |  0.06
Output  | 0.00015225 | 0.00015225 | 0.00015225 |   0.0 |  0.00
Modify  | 0.35137    | 0.35137    | 0.35137    |   0.0 |  0.23
Other   |            | 0.05958    |            |       |  0.04

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

Total # of neighbors = 128176
Ave neighs/atom = 64.088000
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 = 252.975419422123, Press = 0.6382250371651
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8451.1424   -8451.1424   -8513.9901   -8513.9901    243.22691    243.22691      23302.9      23302.9    2640.8722    2640.8722 
   43000   -8447.6792   -8447.6792    -8512.695    -8512.695    251.61782    251.61782     23375.41     23375.41   -1968.3723   -1968.3723 
Loop time of 152.298 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.305 hours/ns, 6.566 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.79     | 151.79     | 151.79     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094944   | 0.094944   | 0.094944   |   0.0 |  0.06
Output  | 0.00015304 | 0.00015304 | 0.00015304 |   0.0 |  0.00
Modify  | 0.35175    | 0.35175    | 0.35175    |   0.0 |  0.23
Other   |            | 0.05917    |            |       |  0.04

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

Total # of neighbors = 128202
Ave neighs/atom = 64.101000
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 = 252.95712964199, Press = -0.486370904822437
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8447.6792   -8447.6792    -8512.695    -8512.695    251.61782    251.61782     23375.41     23375.41   -1968.3723   -1968.3723 
   44000   -8446.2405   -8446.2405   -8511.0691   -8511.0691    250.89332    250.89332    23335.921    23335.921    913.96973    913.96973 
Loop time of 152.259 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.294 hours/ns, 6.568 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    | 151.75     | 151.75     | 151.75     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095182   | 0.095182   | 0.095182   |   0.0 |  0.06
Output  | 0.00015348 | 0.00015348 | 0.00015348 |   0.0 |  0.00
Modify  | 0.35153    | 0.35153    | 0.35153    |   0.0 |  0.23
Other   |            | 0.05933    |            |       |  0.04

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

Total # of neighbors = 128184
Ave neighs/atom = 64.092000
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 = 252.95689186189, Press = -0.728219917708635
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8446.2405   -8446.2405   -8511.0691   -8511.0691    250.89332    250.89332    23335.921    23335.921    913.96973    913.96973 
   45000   -8449.0942   -8449.0942   -8513.6432   -8513.6432    249.81117    249.81117    23353.382    23353.382   -580.50268   -580.50268 
Loop time of 151.454 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.070 hours/ns, 6.603 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    | 150.95     | 150.95     | 150.95     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093737   | 0.093737   | 0.093737   |   0.0 |  0.06
Output  | 0.000153   | 0.000153   | 0.000153   |   0.0 |  0.00
Modify  | 0.35074    | 0.35074    | 0.35074    |   0.0 |  0.23
Other   |            | 0.0592     |            |       |  0.04

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

Total # of neighbors = 128204
Ave neighs/atom = 64.102000
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 = 252.932621454082, Press = 0.168426815733713
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -8449.0942   -8449.0942   -8513.6432   -8513.6432    249.81117    249.81117    23353.382    23353.382   -580.50268   -580.50268 
   46000     -8444.35     -8444.35    -8510.204    -8510.204    254.86201    254.86201    23370.172    23370.172   -1278.0566   -1278.0566 
Loop time of 151.918 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.199 hours/ns, 6.582 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    | 151.41     | 151.41     | 151.41     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093436   | 0.093436   | 0.093436   |   0.0 |  0.06
Output  | 0.00015558 | 0.00015558 | 0.00015558 |   0.0 |  0.00
Modify  | 0.35123    | 0.35123    | 0.35123    |   0.0 |  0.23
Other   |            | 0.05971    |            |       |  0.04

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

Total # of neighbors = 128168
Ave neighs/atom = 64.084000
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 = 252.938317228481, Press = -3.08393742574153
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000     -8444.35     -8444.35    -8510.204    -8510.204    254.86201    254.86201    23370.172    23370.172   -1278.0566   -1278.0566 
   47000   -8446.7832   -8446.7832   -8512.0005   -8512.0005    252.39785    252.39785    23308.369    23308.369    2775.6165    2775.6165 
Loop time of 152.011 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.225 hours/ns, 6.578 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    | 151.51     | 151.51     | 151.51     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093709   | 0.093709   | 0.093709   |   0.0 |  0.06
Output  | 0.00015196 | 0.00015196 | 0.00015196 |   0.0 |  0.00
Modify  | 0.35177    | 0.35177    | 0.35177    |   0.0 |  0.23
Other   |            | 0.05966    |            |       |  0.04

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

Total # of neighbors = 128164
Ave neighs/atom = 64.082000
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 = 252.990683027814, Press = 0.567062466787998
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -8446.7832   -8446.7832   -8512.0005   -8512.0005    252.39785    252.39785    23308.369    23308.369    2775.6165    2775.6165 
   48000   -8445.0638   -8445.0638   -8510.5172   -8510.5172    253.31112    253.31112    23368.595    23368.595   -1123.4047   -1123.4047 
Loop time of 152.133 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.259 hours/ns, 6.573 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    | 151.63     | 151.63     | 151.63     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093766   | 0.093766   | 0.093766   |   0.0 |  0.06
Output  | 0.00015313 | 0.00015313 | 0.00015313 |   0.0 |  0.00
Modify  | 0.35088    | 0.35088    | 0.35088    |   0.0 |  0.23
Other   |            | 0.05928    |            |       |  0.04

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

Total # of neighbors = 128230
Ave neighs/atom = 64.115000
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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
23347.0645233084

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0