# 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.850243076682091*${_u_distance}
variable latticeconst_converted equal 2.850243076682091*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85024307668209
Lattice spacing in x,y,z = 2.8502431 2.8502431 2.8502431
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.502431 28.502431 28.502431)
  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.502431 28.502431 28.502431)
  create_atoms CPU = 0.003 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_MahataMukhopadhyayAsleZaeem_2022_AlFe__MO_304347095149_000
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 23155.0486762528    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23155.0486762528/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23155.0486762528/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23155.0486762528/(1*1*${_u_distance})
variable      V0_metal equal 23155.0486762528/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23155.0486762528*1000

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8510.0982   -8510.0982   -8580.6777   -8580.6777       273.15       273.15    23155.049    23155.049    3255.7541    3255.7541 
    1000   -8437.3034   -8437.3034   -8506.6508   -8506.6508    268.38164    268.38164    23342.958    23342.958    1237.9583    1237.9583 
Loop time of 259.661 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.333 ns/day, 72.128 hours/ns, 3.851 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 259.08     | 259.08     | 259.08     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10623    | 0.10623    | 0.10623    |   0.0 |  0.04
Output  | 0.00026946 | 0.00026946 | 0.00026946 |   0.0 |  0.00
Modify  | 0.40669    | 0.40669    | 0.40669    |   0.0 |  0.16
Other   |            | 0.06367    |            |       |  0.02

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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8437.3034   -8437.3034   -8506.6508   -8506.6508    268.38164    268.38164    23342.958    23342.958    1237.9583    1237.9583 
    2000   -8436.5883   -8436.5883   -8505.3359   -8505.3359    266.06045    266.06045    23393.662    23393.662   -2128.3128   -2128.3128 
Loop time of 233.597 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.370 ns/day, 64.888 hours/ns, 4.281 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    | 233.1      | 233.1      | 233.1      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097596   | 0.097596   | 0.097596   |   0.0 |  0.04
Output  | 0.00019782 | 0.00019782 | 0.00019782 |   0.0 |  0.00
Modify  | 0.34311    | 0.34311    | 0.34311    |   0.0 |  0.15
Other   |            | 0.05843    |            |       |  0.03

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:      132196.0 ave      132196 max      132196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 132196
Ave neighs/atom = 66.098000
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8436.5883   -8436.5883   -8505.3359   -8505.3359    266.06045    266.06045    23393.662    23393.662   -2128.3128   -2128.3128 
    3000   -8438.4943   -8438.4943   -8511.8004   -8511.8004    283.70238    283.70238    23374.376    23374.376   -1517.8513   -1517.8513 
Loop time of 229.153 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.654 hours/ns, 4.364 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    | 228.66     | 228.66     | 228.66     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096012   | 0.096012   | 0.096012   |   0.0 |  0.04
Output  | 0.00019085 | 0.00019085 | 0.00019085 |   0.0 |  0.00
Modify  | 0.3348     | 0.3348     | 0.3348     |   0.0 |  0.15
Other   |            | 0.05707    |            |       |  0.02

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:      131526.0 ave      131526 max      131526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131526
Ave neighs/atom = 65.763000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8438.4943   -8438.4943   -8511.8004   -8511.8004    283.70238    283.70238    23374.376    23374.376   -1517.8513   -1517.8513 
    4000    -8436.162    -8436.162   -8504.2277   -8504.2277    263.42163    263.42163    23358.183    23358.183     527.8421     527.8421 
Loop time of 229.328 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.702 hours/ns, 4.361 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    | 228.84     | 228.84     | 228.84     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096129   | 0.096129   | 0.096129   |   0.0 |  0.04
Output  | 0.00022686 | 0.00022686 | 0.00022686 |   0.0 |  0.00
Modify  | 0.33305    | 0.33305    | 0.33305    |   0.0 |  0.15
Other   |            | 0.05782    |            |       |  0.03

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:      131012.0 ave      131012 max      131012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131012
Ave neighs/atom = 65.506000
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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    -8436.162    -8436.162   -8504.2277   -8504.2277    263.42163    263.42163    23358.183    23358.183     527.8421     527.8421 
    5000   -8438.5473   -8438.5473   -8511.2398   -8511.2398    281.32731    281.32731    23350.889    23350.889    228.73182    228.73182 
Loop time of 256.022 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.337 ns/day, 71.117 hours/ns, 3.906 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    | 255.45     | 255.45     | 255.45     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10532    | 0.10532    | 0.10532    |   0.0 |  0.04
Output  | 0.00022775 | 0.00022775 | 0.00022775 |   0.0 |  0.00
Modify  | 0.40261    | 0.40261    | 0.40261    |   0.0 |  0.16
Other   |            | 0.06327    |            |       |  0.02

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:      131940.0 ave      131940 max      131940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131940
Ave neighs/atom = 65.970000
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 = 269.271776713428, Press = -138.283180797713
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8438.5473   -8438.5473   -8511.2398   -8511.2398    281.32731    281.32731    23350.889    23350.889    228.73182    228.73182 
    6000    -8436.469    -8436.469   -8505.4441   -8505.4441    266.94084    266.94084    23348.839    23348.839    1197.0405    1197.0405 
Loop time of 248.363 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.348 ns/day, 68.990 hours/ns, 4.026 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 247.8      | 247.8      | 247.8      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10386    | 0.10386    | 0.10386    |   0.0 |  0.04
Output  | 0.00015795 | 0.00015795 | 0.00015795 |   0.0 |  0.00
Modify  | 0.39974    | 0.39974    | 0.39974    |   0.0 |  0.16
Other   |            | 0.06115    |            |       |  0.02

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:      131256.0 ave      131256 max      131256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131256
Ave neighs/atom = 65.628000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.350885416916, Press = -5.22620867208062
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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    -8436.469    -8436.469   -8505.4441   -8505.4441    266.94084    266.94084    23348.839    23348.839    1197.0405    1197.0405 
    7000   -8439.0813   -8439.0813   -8509.9578   -8509.9578    274.29949    274.29949    23365.684    23365.684   -740.20028   -740.20028 
Loop time of 232.703 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.371 ns/day, 64.640 hours/ns, 4.297 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    | 232.19     | 232.19     | 232.19     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097624   | 0.097624   | 0.097624   |   0.0 |  0.04
Output  | 0.00019495 | 0.00019495 | 0.00019495 |   0.0 |  0.00
Modify  | 0.3589     | 0.3589     | 0.3589     |   0.0 |  0.15
Other   |            | 0.05779    |            |       |  0.02

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:      131768.0 ave      131768 max      131768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131768
Ave neighs/atom = 65.884000
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 = 271.644354288695, Press = 21.5734497625026
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8439.0813   -8439.0813   -8509.9578   -8509.9578    274.29949    274.29949    23365.684    23365.684   -740.20028   -740.20028 
    8000   -8437.3202   -8437.3202   -8506.3341   -8506.3341    267.09088    267.09088     23392.01     23392.01   -1976.7846   -1976.7846 
Loop time of 255.682 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.338 ns/day, 71.023 hours/ns, 3.911 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 255.09     | 255.09     | 255.09     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10635    | 0.10635    | 0.10635    |   0.0 |  0.04
Output  | 0.00015802 | 0.00015802 | 0.00015802 |   0.0 |  0.00
Modify  | 0.41912    | 0.41912    | 0.41912    |   0.0 |  0.16
Other   |            | 0.06297    |            |       |  0.02

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:      131460.0 ave      131460 max      131460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131460
Ave neighs/atom = 65.730000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.644096617496, Press = -3.56960641139722
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8437.3202   -8437.3202   -8506.3341   -8506.3341    267.09088    267.09088     23392.01     23392.01   -1976.7846   -1976.7846 
    9000   -8442.4533   -8442.4533   -8510.5132   -8510.5132    263.39888    263.39888     23383.56     23383.56   -2093.6633   -2093.6633 
Loop time of 264.054 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.327 ns/day, 73.348 hours/ns, 3.787 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 263.44     | 263.44     | 263.44     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10968    | 0.10968    | 0.10968    |   0.0 |  0.04
Output  | 0.00014821 | 0.00014821 | 0.00014821 |   0.0 |  0.00
Modify  | 0.43997    | 0.43997    | 0.43997    |   0.0 |  0.17
Other   |            | 0.06431    |            |       |  0.02

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:      131272.0 ave      131272 max      131272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131272
Ave neighs/atom = 65.636000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.149659732109, Press = -18.8421264298654
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8442.4533   -8442.4533   -8510.5132   -8510.5132    263.39888    263.39888     23383.56     23383.56   -2093.6633   -2093.6633 
   10000   -8436.5663   -8436.5663   -8508.3359   -8508.3359    277.75579    277.75579    23339.862    23339.862    1500.1147    1500.1147 
Loop time of 256.448 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.337 ns/day, 71.236 hours/ns, 3.899 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    | 255.86     | 255.86     | 255.86     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1071     | 0.1071     | 0.1071     |   0.0 |  0.04
Output  | 0.00015432 | 0.00015432 | 0.00015432 |   0.0 |  0.00
Modify  | 0.42123    | 0.42123    | 0.42123    |   0.0 |  0.16
Other   |            | 0.06293    |            |       |  0.02

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:      131090.0 ave      131090 max      131090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131090
Ave neighs/atom = 65.545000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.013772372305, Press = -14.6423170167739
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8436.5663   -8436.5663   -8508.3359   -8508.3359    277.75579    277.75579    23339.862    23339.862    1500.1147    1500.1147 
   11000   -8439.3579   -8439.3579   -8510.9434   -8510.9434    277.04317    277.04317    23331.949    23331.949    1568.6848    1568.6848 
Loop time of 231.386 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.274 hours/ns, 4.322 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    | 230.87     | 230.87     | 230.87     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097864   | 0.097864   | 0.097864   |   0.0 |  0.04
Output  | 0.00015437 | 0.00015437 | 0.00015437 |   0.0 |  0.00
Modify  | 0.35651    | 0.35651    | 0.35651    |   0.0 |  0.15
Other   |            | 0.05774    |            |       |  0.02

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:      131644.0 ave      131644 max      131644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131644
Ave neighs/atom = 65.822000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.252783606189, Press = 0.144329100383718
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8439.3579   -8439.3579   -8510.9434   -8510.9434    277.04317    277.04317    23331.949    23331.949    1568.6848    1568.6848 
   12000   -8436.5844   -8436.5844   -8507.9985   -8507.9985    276.37984    276.37984    23355.058    23355.058    428.03768    428.03768 
Loop time of 230.125 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.924 hours/ns, 4.345 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    | 229.62     | 229.62     | 229.62     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097471   | 0.097471   | 0.097471   |   0.0 |  0.04
Output  | 0.00018856 | 0.00018856 | 0.00018856 |   0.0 |  0.00
Modify  | 0.3541     | 0.3541     | 0.3541     |   0.0 |  0.15
Other   |            | 0.05683    |            |       |  0.02

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:      131558.0 ave      131558 max      131558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131558
Ave neighs/atom = 65.779000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.051621572717, Press = 2.45029033253723
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8436.5844   -8436.5844   -8507.9985   -8507.9985    276.37984    276.37984    23355.058    23355.058    428.03768    428.03768 
   13000    -8439.233    -8439.233    -8507.507    -8507.507    264.22743    264.22743     23353.17     23353.17    407.78289    407.78289 
Loop time of 254.619 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.339 ns/day, 70.727 hours/ns, 3.927 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    | 254.04     | 254.04     | 254.04     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10684    | 0.10684    | 0.10684    |   0.0 |  0.04
Output  | 0.00015657 | 0.00015657 | 0.00015657 |   0.0 |  0.00
Modify  | 0.41365    | 0.41365    | 0.41365    |   0.0 |  0.16
Other   |            | 0.06208    |            |       |  0.02

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:      131328.0 ave      131328 max      131328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131328
Ave neighs/atom = 65.664000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.080755672962, Press = 2.97322292865982
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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    -8439.233    -8439.233    -8507.507    -8507.507    264.22743    264.22743     23353.17     23353.17    407.78289    407.78289 
   14000   -8436.7707   -8436.7707    -8506.966    -8506.966    271.66324    271.66324    23379.446    23379.446   -1216.3247   -1216.3247 
Loop time of 264.633 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.326 ns/day, 73.509 hours/ns, 3.779 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    | 264.02     | 264.02     | 264.02     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10947    | 0.10947    | 0.10947    |   0.0 |  0.04
Output  | 0.00019917 | 0.00019917 | 0.00019917 |   0.0 |  0.00
Modify  | 0.4408     | 0.4408     | 0.4408     |   0.0 |  0.17
Other   |            | 0.06457    |            |       |  0.02

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:      131514.0 ave      131514 max      131514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131514
Ave neighs/atom = 65.757000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.462621375591, Press = -0.939298274547677
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8436.7707   -8436.7707    -8506.966    -8506.966    271.66324    271.66324    23379.446    23379.446   -1216.3247   -1216.3247 
   15000   -8435.5913   -8435.5913   -8506.5323   -8506.5323    274.54896    274.54896    23388.923    23388.923   -1747.4973   -1747.4973 
Loop time of 235.423 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.367 ns/day, 65.395 hours/ns, 4.248 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    | 234.9      | 234.9      | 234.9      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098795   | 0.098795   | 0.098795   |   0.0 |  0.04
Output  | 0.00043454 | 0.00043454 | 0.00043454 |   0.0 |  0.00
Modify  | 0.36708    | 0.36708    | 0.36708    |   0.0 |  0.16
Other   |            | 0.05858    |            |       |  0.02

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:      131534.0 ave      131534 max      131534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131534
Ave neighs/atom = 65.767000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.604935584994, Press = -8.8457572431719
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8435.5913   -8435.5913   -8506.5323   -8506.5323    274.54896    274.54896    23388.923    23388.923   -1747.4973   -1747.4973 
   16000   -8439.3334   -8439.3334   -8509.2147   -8509.2147    270.44767    270.44767     23330.23     23330.23    1918.8257    1918.8257 
Loop time of 228.58 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.494 hours/ns, 4.375 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    | 228.07     | 228.07     | 228.07     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095406   | 0.095406   | 0.095406   |   0.0 |  0.04
Output  | 0.00015389 | 0.00015389 | 0.00015389 |   0.0 |  0.00
Modify  | 0.3523     | 0.3523     | 0.3523     |   0.0 |  0.15
Other   |            | 0.05782    |            |       |  0.03

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:      131432.0 ave      131432 max      131432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131432
Ave neighs/atom = 65.716000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.808570026277, Press = -5.19340511998533
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8439.3334   -8439.3334   -8509.2147   -8509.2147    270.44767    270.44767     23330.23     23330.23    1918.8257    1918.8257 
   17000    -8437.832    -8437.832   -8507.8658   -8507.8658    271.03821    271.03821    23327.151    23327.151     2278.514     2278.514 
Loop time of 243.572 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.355 ns/day, 67.659 hours/ns, 4.106 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    | 243.02     | 243.02     | 243.02     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10174    | 0.10174    | 0.10174    |   0.0 |  0.04
Output  | 0.00015472 | 0.00015472 | 0.00015472 |   0.0 |  0.00
Modify  | 0.38671    | 0.38671    | 0.38671    |   0.0 |  0.16
Other   |            | 0.06017    |            |       |  0.02

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:      131606.0 ave      131606 max      131606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131606
Ave neighs/atom = 65.803000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.89221106757, Press = 1.16971331239761
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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    -8437.832    -8437.832   -8507.8658   -8507.8658    271.03821    271.03821    23327.151    23327.151     2278.514     2278.514 
   18000   -8436.9219   -8436.9219   -8505.1557   -8505.1557    264.07166    264.07166     23357.17     23357.17    596.21589    596.21589 
Loop time of 262.847 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.329 ns/day, 73.013 hours/ns, 3.804 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.24     | 262.24     | 262.24     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10843    | 0.10843    | 0.10843    |   0.0 |  0.04
Output  | 0.00021517 | 0.00021517 | 0.00021517 |   0.0 |  0.00
Modify  | 0.43648    | 0.43648    | 0.43648    |   0.0 |  0.17
Other   |            | 0.06415    |            |       |  0.02

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:      131828.0 ave      131828 max      131828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131828
Ave neighs/atom = 65.914000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.924049733116, Press = 1.43921797129316
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8436.9219   -8436.9219   -8505.1557   -8505.1557    264.07166    264.07166     23357.17     23357.17    596.21589    596.21589 
   19000    -8437.353    -8437.353   -8509.1146   -8509.1146    277.72492    277.72492    23368.944    23368.944   -696.05543   -696.05543 
Loop time of 264.38 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.327 ns/day, 73.439 hours/ns, 3.782 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 263.77     | 263.77     | 263.77     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10836    | 0.10836    | 0.10836    |   0.0 |  0.04
Output  | 0.0001844  | 0.0001844  | 0.0001844  |   0.0 |  0.00
Modify  | 0.44066    | 0.44066    | 0.44066    |   0.0 |  0.17
Other   |            | 0.06397    |            |       |  0.02

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:      131724.0 ave      131724 max      131724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131724
Ave neighs/atom = 65.862000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.924971544368, Press = -0.12147579231232
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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    -8437.353    -8437.353   -8509.1146   -8509.1146    277.72492    277.72492    23368.944    23368.944   -696.05543   -696.05543 
   20000   -8439.0123   -8439.0123   -8508.6956   -8508.6956     269.6817     269.6817    23362.556    23362.556   -311.63573   -311.63573 
Loop time of 264.629 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.326 ns/day, 73.508 hours/ns, 3.779 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    | 264.02     | 264.02     | 264.02     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10856    | 0.10856    | 0.10856    |   0.0 |  0.04
Output  | 0.00015328 | 0.00015328 | 0.00015328 |   0.0 |  0.00
Modify  | 0.44057    | 0.44057    | 0.44057    |   0.0 |  0.17
Other   |            | 0.06389    |            |       |  0.02

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:      131314.0 ave      131314 max      131314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131314
Ave neighs/atom = 65.657000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.946994235163, Press = -1.28004456347142
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8439.0123   -8439.0123   -8508.6956   -8508.6956     269.6817     269.6817    23362.556    23362.556   -311.63573   -311.63573 
   21000    -8438.053    -8438.053   -8508.4055   -8508.4055    272.27123    272.27123    23354.415    23354.415     326.8747     326.8747 
Loop time of 264.779 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.326 ns/day, 73.550 hours/ns, 3.777 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 264.16     | 264.16     | 264.16     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10911    | 0.10911    | 0.10911    |   0.0 |  0.04
Output  | 0.00015548 | 0.00015548 | 0.00015548 |   0.0 |  0.00
Modify  | 0.44496    | 0.44496    | 0.44496    |   0.0 |  0.17
Other   |            | 0.06481    |            |       |  0.02

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:      131312.0 ave      131312 max      131312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131312
Ave neighs/atom = 65.656000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.781970743632, Press = -1.05928200466057
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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    -8438.053    -8438.053   -8508.4055   -8508.4055    272.27123    272.27123    23354.415    23354.415     326.8747     326.8747 
   22000   -8436.8213   -8436.8213   -8506.5082   -8506.5082    269.69562    269.69562    23349.469    23349.469      950.476      950.476 
Loop time of 264.466 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.327 ns/day, 73.463 hours/ns, 3.781 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 263.85     | 263.85     | 263.85     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10987    | 0.10987    | 0.10987    |   0.0 |  0.04
Output  | 0.00021692 | 0.00021692 | 0.00021692 |   0.0 |  0.00
Modify  | 0.44294    | 0.44294    | 0.44294    |   0.0 |  0.17
Other   |            | 0.06468    |            |       |  0.02

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:      131314.0 ave      131314 max      131314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131314
Ave neighs/atom = 65.657000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.821052940168, Press = -0.980879620769798
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8436.8213   -8436.8213   -8506.5082   -8506.5082    269.69562    269.69562    23349.469    23349.469      950.476      950.476 
   23000   -8437.2475   -8437.2475   -8508.2092   -8508.2092    274.62927    274.62927    23351.469    23351.469    636.56156    636.56156 
Loop time of 264.688 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.326 ns/day, 73.524 hours/ns, 3.778 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    | 264.07     | 264.07     | 264.07     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10917    | 0.10917    | 0.10917    |   0.0 |  0.04
Output  | 0.00015404 | 0.00015404 | 0.00015404 |   0.0 |  0.00
Modify  | 0.44124    | 0.44124    | 0.44124    |   0.0 |  0.17
Other   |            | 0.06466    |            |       |  0.02

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:      131508.0 ave      131508 max      131508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131508
Ave neighs/atom = 65.754000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.840895932478, Press = 0.37621095547504
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8437.2475   -8437.2475   -8508.2092   -8508.2092    274.62927    274.62927    23351.469    23351.469    636.56156    636.56156 
   24000   -8436.8597   -8436.8597   -8508.5301   -8508.5301    277.37166    277.37166    23370.967    23370.967   -697.17647   -697.17647 
Loop time of 258.684 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.334 ns/day, 71.857 hours/ns, 3.866 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 258.09     | 258.09     | 258.09     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10785    | 0.10785    | 0.10785    |   0.0 |  0.04
Output  | 0.000155   | 0.000155   | 0.000155   |   0.0 |  0.00
Modify  | 0.42639    | 0.42639    | 0.42639    |   0.0 |  0.16
Other   |            | 0.06362    |            |       |  0.02

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:      131556.0 ave      131556 max      131556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131556
Ave neighs/atom = 65.778000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.810134837411, Press = 1.51746520513419
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8436.8597   -8436.8597   -8508.5301   -8508.5301    277.37166    277.37166    23370.967    23370.967   -697.17647   -697.17647 
   25000    -8438.756    -8438.756   -8507.9318   -8507.9318    267.71725    267.71725    23387.234    23387.234   -1875.5798   -1875.5798 
Loop time of 261.807 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.330 ns/day, 72.724 hours/ns, 3.820 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    | 261.2      | 261.2      | 261.2      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1081     | 0.1081     | 0.1081     |   0.0 |  0.04
Output  | 0.00019606 | 0.00019606 | 0.00019606 |   0.0 |  0.00
Modify  | 0.43265    | 0.43265    | 0.43265    |   0.0 |  0.17
Other   |            | 0.06338    |            |       |  0.02

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:      131246.0 ave      131246 max      131246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131246
Ave neighs/atom = 65.623000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.825852644167, Press = -1.03738447275391
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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    -8438.756    -8438.756   -8507.9318   -8507.9318    267.71725    267.71725    23387.234    23387.234   -1875.5798   -1875.5798 
   26000    -8438.497    -8438.497   -8506.2932   -8506.2932    262.37855    262.37855    23378.334    23378.334   -1045.8005   -1045.8005 
Loop time of 266.173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.325 ns/day, 73.937 hours/ns, 3.757 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 265.55     | 265.55     | 265.55     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11021    | 0.11021    | 0.11021    |   0.0 |  0.04
Output  | 0.00021397 | 0.00021397 | 0.00021397 |   0.0 |  0.00
Modify  | 0.44481    | 0.44481    | 0.44481    |   0.0 |  0.17
Other   |            | 0.0645     |            |       |  0.02

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:      131178.0 ave      131178 max      131178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131178
Ave neighs/atom = 65.589000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.691107779617, Press = -3.94483400791764
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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    -8438.497    -8438.497   -8506.2932   -8506.2932    262.37855    262.37855    23378.334    23378.334   -1045.8005   -1045.8005 
   27000    -8437.622    -8437.622   -8507.3785   -8507.3785    269.96467    269.96467    23325.685    23325.685    2595.9254    2595.9254 
Loop time of 258.352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.334 ns/day, 71.765 hours/ns, 3.871 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    | 257.76     | 257.76     | 257.76     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10746    | 0.10746    | 0.10746    |   0.0 |  0.04
Output  | 0.00015435 | 0.00015435 | 0.00015435 |   0.0 |  0.00
Modify  | 0.42597    | 0.42597    | 0.42597    |   0.0 |  0.16
Other   |            | 0.06314    |            |       |  0.02

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:      131348.0 ave      131348 max      131348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131348
Ave neighs/atom = 65.674000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.667600234354, Press = -4.51106678384922
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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    -8437.622    -8437.622   -8507.3785   -8507.3785    269.96467    269.96467    23325.685    23325.685    2595.9254    2595.9254 
   28000   -8434.1959   -8434.1959   -8505.8623   -8505.8623    277.35641    277.35641    23309.004    23309.004    3975.4747    3975.4747 
Loop time of 248.72 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.347 ns/day, 69.089 hours/ns, 4.021 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 248.15     | 248.15     | 248.15     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10426    | 0.10426    | 0.10426    |   0.0 |  0.04
Output  | 0.00015248 | 0.00015248 | 0.00015248 |   0.0 |  0.00
Modify  | 0.40265    | 0.40265    | 0.40265    |   0.0 |  0.16
Other   |            | 0.06167    |            |       |  0.02

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:      131702.0 ave      131702 max      131702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131702
Ave neighs/atom = 65.851000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.672439673881, Press = 0.101702741810913
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8434.1959   -8434.1959   -8505.8623   -8505.8623    277.35641    277.35641    23309.004    23309.004    3975.4747    3975.4747 
   29000   -8437.6398   -8437.6398   -8508.1907   -8508.1907    273.03916    273.03916    23351.871    23351.871    542.95345    542.95345 
Loop time of 255.49 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.338 ns/day, 70.970 hours/ns, 3.914 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 254.9      | 254.9      | 254.9      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10596    | 0.10596    | 0.10596    |   0.0 |  0.04
Output  | 0.00021509 | 0.00021509 | 0.00021509 |   0.0 |  0.00
Modify  | 0.41938    | 0.41938    | 0.41938    |   0.0 |  0.16
Other   |            | 0.06288    |            |       |  0.02

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:      132042.0 ave      132042 max      132042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 132042
Ave neighs/atom = 66.021000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.720705349959, Press = 1.48019831192127
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8437.6398   -8437.6398   -8508.1907   -8508.1907    273.03916    273.03916    23351.871    23351.871    542.95345    542.95345 
   30000   -8434.5556   -8434.5556   -8505.8549   -8505.8549    275.93591    275.93591    23379.895    23379.895    -1033.081    -1033.081 
Loop time of 263.887 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.327 ns/day, 73.302 hours/ns, 3.789 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    | 263.27     | 263.27     | 263.27     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10936    | 0.10936    | 0.10936    |   0.0 |  0.04
Output  | 0.00020097 | 0.00020097 | 0.00020097 |   0.0 |  0.00
Modify  | 0.43965    | 0.43965    | 0.43965    |   0.0 |  0.17
Other   |            | 0.06329    |            |       |  0.02

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:      131572.0 ave      131572 max      131572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131572
Ave neighs/atom = 65.786000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.829208824399, Press = 0.949723517361865
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8434.5556   -8434.5556   -8505.8549   -8505.8549    275.93591    275.93591    23379.895    23379.895    -1033.081    -1033.081 
   31000   -8438.3945   -8438.3945   -8507.1699   -8507.1699    266.16794    266.16794    23379.161    23379.161   -1275.1825   -1275.1825 
Loop time of 266.486 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.324 ns/day, 74.024 hours/ns, 3.753 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 265.87     | 265.87     | 265.87     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11004    | 0.11004    | 0.11004    |   0.0 |  0.04
Output  | 0.00015402 | 0.00015402 | 0.00015402 |   0.0 |  0.00
Modify  | 0.44379    | 0.44379    | 0.44379    |   0.0 |  0.17
Other   |            | 0.06455    |            |       |  0.02

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:      131416.0 ave      131416 max      131416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131416
Ave neighs/atom = 65.708000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.901128875693, Press = -1.34817138968238
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8438.3945   -8438.3945   -8507.1699   -8507.1699    266.16794    266.16794    23379.161    23379.161   -1275.1825   -1275.1825 
   32000   -8439.2058   -8439.2058   -8508.3439   -8508.3439    267.57162    267.57162    23352.168    23352.168    526.84739    526.84739 
Loop time of 265.213 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.326 ns/day, 73.670 hours/ns, 3.771 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    | 264.6      | 264.6      | 264.6      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10928    | 0.10928    | 0.10928    |   0.0 |  0.04
Output  | 0.00019114 | 0.00019114 | 0.00019114 |   0.0 |  0.00
Modify  | 0.4407     | 0.4407     | 0.4407     |   0.0 |  0.17
Other   |            | 0.06443    |            |       |  0.02

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:      131454.0 ave      131454 max      131454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131454
Ave neighs/atom = 65.727000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.952645753747, Press = -2.3091397099001
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8439.2058   -8439.2058   -8508.3439   -8508.3439    267.57162    267.57162    23352.168    23352.168    526.84739    526.84739 
   33000   -8436.9924   -8436.9924   -8507.2467   -8507.2467    271.89122    271.89122    23297.098    23297.098    4481.1198    4481.1198 
Loop time of 265.509 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.325 ns/day, 73.753 hours/ns, 3.766 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    | 264.9      | 264.9      | 264.9      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10915    | 0.10915    | 0.10915    |   0.0 |  0.04
Output  | 0.00023705 | 0.00023705 | 0.00023705 |   0.0 |  0.00
Modify  | 0.44026    | 0.44026    | 0.44026    |   0.0 |  0.17
Other   |            | 0.06365    |            |       |  0.02

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:      131512.0 ave      131512 max      131512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131512
Ave neighs/atom = 65.756000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.890762504043, Press = -0.754003703797564
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8436.9924   -8436.9924   -8507.2467   -8507.2467    271.89122    271.89122    23297.098    23297.098    4481.1198    4481.1198 
   34000   -8440.6489   -8440.6489   -8508.1084   -8508.1084    261.07548    261.07548    23332.063    23332.063    1756.2794    1756.2794 
Loop time of 266.392 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.324 ns/day, 73.998 hours/ns, 3.754 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 265.77     | 265.77     | 265.77     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10946    | 0.10946    | 0.10946    |   0.0 |  0.04
Output  | 0.00021676 | 0.00021676 | 0.00021676 |   0.0 |  0.00
Modify  | 0.44483    | 0.44483    | 0.44483    |   0.0 |  0.17
Other   |            | 0.06459    |            |       |  0.02

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:      132046.0 ave      132046 max      132046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 132046
Ave neighs/atom = 66.023000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.861157091651, Press = 1.89525726259572
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8440.6489   -8440.6489   -8508.1084   -8508.1084    261.07548    261.07548    23332.063    23332.063    1756.2794    1756.2794 
   35000   -8436.7909   -8436.7909   -8507.2997   -8507.2997    272.87613    272.87613     23370.15     23370.15   -575.89692   -575.89692 
Loop time of 263.036 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.328 ns/day, 73.065 hours/ns, 3.802 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    | 262.43     | 262.43     | 262.43     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10805    | 0.10805    | 0.10805    |   0.0 |  0.04
Output  | 0.00019652 | 0.00019652 | 0.00019652 |   0.0 |  0.00
Modify  | 0.43451    | 0.43451    | 0.43451    |   0.0 |  0.17
Other   |            | 0.06367    |            |       |  0.02

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:      131672.0 ave      131672 max      131672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131672
Ave neighs/atom = 65.836000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.81664617014, Press = 1.13126712464344
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8436.7909   -8436.7909   -8507.2997   -8507.2997    272.87613    272.87613     23370.15     23370.15   -575.89692   -575.89692 
   36000   -8440.9042   -8440.9042   -8507.4133   -8507.4133    257.39717    257.39717    23383.013    23383.013   -1684.1242   -1684.1242 
Loop time of 261.474 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.330 ns/day, 72.632 hours/ns, 3.824 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.87     | 260.87     | 260.87     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10752    | 0.10752    | 0.10752    |   0.0 |  0.04
Output  | 0.00021252 | 0.00021252 | 0.00021252 |   0.0 |  0.00
Modify  | 0.43342    | 0.43342    | 0.43342    |   0.0 |  0.17
Other   |            | 0.06439    |            |       |  0.02

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:      131390.0 ave      131390 max      131390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131390
Ave neighs/atom = 65.695000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.786753128278, Press = 0.0186675302398129
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8440.9042   -8440.9042   -8507.4133   -8507.4133    257.39717    257.39717    23383.013    23383.013   -1684.1242   -1684.1242 
   37000   -8436.7029   -8436.7029   -8507.7607   -8507.7607    275.00087    275.00087    23382.241    23382.241   -1466.9931   -1466.9931 
Loop time of 253.439 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.341 ns/day, 70.400 hours/ns, 3.946 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 252.86     | 252.86     | 252.86     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10606    | 0.10606    | 0.10606    |   0.0 |  0.04
Output  | 0.00015462 | 0.00015462 | 0.00015462 |   0.0 |  0.00
Modify  | 0.41164    | 0.41164    | 0.41164    |   0.0 |  0.16
Other   |            | 0.06254    |            |       |  0.02

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:      131398.0 ave      131398 max      131398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131398
Ave neighs/atom = 65.699000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.750960888307, Press = -1.86084221452282
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8436.7029   -8436.7029   -8507.7607   -8507.7607    275.00087    275.00087    23382.241    23382.241   -1466.9931   -1466.9931 
   38000   -8438.6678   -8438.6678   -8509.2314   -8509.2314    273.08856    273.08856    23338.624    23338.624    1279.4825    1279.4825 
Loop time of 249.215 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.347 ns/day, 69.226 hours/ns, 4.013 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    | 248.65     | 248.65     | 248.65     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1037     | 0.1037     | 0.1037     |   0.0 |  0.04
Output  | 0.00015752 | 0.00015752 | 0.00015752 |   0.0 |  0.00
Modify  | 0.39789    | 0.39789    | 0.39789    |   0.0 |  0.16
Other   |            | 0.06107    |            |       |  0.02

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:      131240.0 ave      131240 max      131240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131240
Ave neighs/atom = 65.620000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.743793774428, Press = -1.78926285893842
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8438.6678   -8438.6678   -8509.2314   -8509.2314    273.08856    273.08856    23338.624    23338.624    1279.4825    1279.4825 
   39000   -8437.2142   -8437.2142   -8506.9516   -8506.9516    269.89089    269.89089    23340.295    23340.295    1546.6208    1546.6208 
Loop time of 229.133 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.648 hours/ns, 4.364 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    | 228.63     | 228.63     | 228.63     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095647   | 0.095647   | 0.095647   |   0.0 |  0.04
Output  | 0.00015617 | 0.00015617 | 0.00015617 |   0.0 |  0.00
Modify  | 0.35066    | 0.35066    | 0.35066    |   0.0 |  0.15
Other   |            | 0.05742    |            |       |  0.03

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:      131542.0 ave      131542 max      131542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131542
Ave neighs/atom = 65.771000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.831405342643, Press = -0.459104531344313
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8437.2142   -8437.2142   -8506.9516   -8506.9516    269.89089    269.89089    23340.295    23340.295    1546.6208    1546.6208 
   40000   -8437.2242   -8437.2242    -8508.656    -8508.656    276.44828    276.44828    23356.493    23356.493    190.25321    190.25321 
Loop time of 229.352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.709 hours/ns, 4.360 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    | 228.85     | 228.85     | 228.85     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095944   | 0.095944   | 0.095944   |   0.0 |  0.04
Output  | 0.00019095 | 0.00019095 | 0.00019095 |   0.0 |  0.00
Modify  | 0.35005    | 0.35005    | 0.35005    |   0.0 |  0.15
Other   |            | 0.05707    |            |       |  0.02

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:      131660.0 ave      131660 max      131660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131660
Ave neighs/atom = 65.830000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.822161298238, Press = 0.390028797003229
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8437.2242   -8437.2242    -8508.656    -8508.656    276.44828    276.44828    23356.493    23356.493    190.25321    190.25321 
   41000   -8437.4819   -8437.4819   -8508.4805   -8508.4805    274.77195    274.77195     23363.52     23363.52   -234.29119   -234.29119 
Loop time of 235.595 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.367 ns/day, 65.443 hours/ns, 4.245 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    | 235.07     | 235.07     | 235.07     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09799    | 0.09799    | 0.09799    |   0.0 |  0.04
Output  | 0.00043802 | 0.00043802 | 0.00043802 |   0.0 |  0.00
Modify  | 0.36493    | 0.36493    | 0.36493    |   0.0 |  0.15
Other   |            | 0.05861    |            |       |  0.02

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:      131428.0 ave      131428 max      131428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131428
Ave neighs/atom = 65.714000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.828364862958, Press = -0.134175804237386
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8437.4819   -8437.4819   -8508.4805   -8508.4805    274.77195    274.77195     23363.52     23363.52   -234.29119   -234.29119 
   42000   -8435.8479   -8435.8479    -8506.045    -8506.045    271.66998    271.66998    23380.224    23380.224   -1118.5908   -1118.5908 
Loop time of 256.977 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.336 ns/day, 71.383 hours/ns, 3.891 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 256.39     | 256.39     | 256.39     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10622    | 0.10622    | 0.10622    |   0.0 |  0.04
Output  | 0.00015502 | 0.00015502 | 0.00015502 |   0.0 |  0.00
Modify  | 0.4197     | 0.4197     | 0.4197     |   0.0 |  0.16
Other   |            | 0.06353    |            |       |  0.02

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:      131448.0 ave      131448 max      131448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131448
Ave neighs/atom = 65.724000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.814884656204, Press = -0.362375590831578
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8435.8479   -8435.8479    -8506.045    -8506.045    271.66998    271.66998    23380.224    23380.224   -1118.5908   -1118.5908 
   43000   -8438.2717   -8438.2717   -8508.0633   -8508.0633     270.1008     270.1008    23376.686    23376.686   -1270.1601   -1270.1601 
Loop time of 241.028 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.358 ns/day, 66.952 hours/ns, 4.149 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    | 240.49     | 240.49     | 240.49     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10045    | 0.10045    | 0.10045    |   0.0 |  0.04
Output  | 0.0001557  | 0.0001557  | 0.0001557  |   0.0 |  0.00
Modify  | 0.38115    | 0.38115    | 0.38115    |   0.0 |  0.16
Other   |            | 0.05951    |            |       |  0.02

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:      131526.0 ave      131526 max      131526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131526
Ave neighs/atom = 65.763000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.842524834332, Press = -2.02792311132964
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8438.2717   -8438.2717   -8508.0633   -8508.0633     270.1008     270.1008    23376.686    23376.686   -1270.1601   -1270.1601 
   44000   -8433.8543   -8433.8543   -8505.3787   -8505.3787    276.80695    276.80695    23348.156    23348.156    1340.8619    1340.8619 
Loop time of 258.652 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.334 ns/day, 71.848 hours/ns, 3.866 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 258.06     | 258.06     | 258.06     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10736    | 0.10736    | 0.10736    |   0.0 |  0.04
Output  | 0.00015538 | 0.00015538 | 0.00015538 |   0.0 |  0.00
Modify  | 0.42559    | 0.42559    | 0.42559    |   0.0 |  0.16
Other   |            | 0.06344    |            |       |  0.02

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:      131406.0 ave      131406 max      131406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131406
Ave neighs/atom = 65.703000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.905547235295, Press = -1.26335112770068
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8433.8543   -8433.8543   -8505.3787   -8505.3787    276.80695    276.80695    23348.156    23348.156    1340.8619    1340.8619 
   45000   -8438.0359   -8438.0359   -8509.4206   -8509.4206    276.26605    276.26605    23318.018    23318.018    2763.9538    2763.9538 
Loop time of 252.786 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.342 ns/day, 70.218 hours/ns, 3.956 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 252.21     | 252.21     | 252.21     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10557    | 0.10557    | 0.10557    |   0.0 |  0.04
Output  | 0.00015593 | 0.00015593 | 0.00015593 |   0.0 |  0.00
Modify  | 0.41151    | 0.41151    | 0.41151    |   0.0 |  0.16
Other   |            | 0.06237    |            |       |  0.02

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:      131650.0 ave      131650 max      131650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131650
Ave neighs/atom = 65.825000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.973670233614, Press = 0.390422438620099
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8438.0359   -8438.0359   -8509.4206   -8509.4206    276.26605    276.26605    23318.018    23318.018    2763.9538    2763.9538 
   46000   -8435.4909   -8435.4909   -8506.7423   -8506.7423    275.75061    275.75061    23361.759    23361.759    49.224759    49.224759 
Loop time of 254.203 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.340 ns/day, 70.612 hours/ns, 3.934 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    | 253.62     | 253.62     | 253.62     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10608    | 0.10608    | 0.10608    |   0.0 |  0.04
Output  | 0.00020776 | 0.00020776 | 0.00020776 |   0.0 |  0.00
Modify  | 0.41245    | 0.41245    | 0.41245    |   0.0 |  0.16
Other   |            | 0.06199    |            |       |  0.02

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:      131610.0 ave      131610 max      131610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131610
Ave neighs/atom = 65.805000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.000473514194, Press = 0.949750394147737
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8435.4909   -8435.4909   -8506.7423   -8506.7423    275.75061    275.75061    23361.759    23361.759    49.224759    49.224759 
   47000   -8441.9982   -8441.9982   -8509.8026   -8509.8026    262.40987    262.40987     23367.89     23367.89   -953.86879   -953.86879 
Loop time of 265.879 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.325 ns/day, 73.855 hours/ns, 3.761 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 265.26     | 265.26     | 265.26     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11085    | 0.11085    | 0.11085    |   0.0 |  0.04
Output  | 0.00015515 | 0.00015515 | 0.00015515 |   0.0 |  0.00
Modify  | 0.44379    | 0.44379    | 0.44379    |   0.0 |  0.17
Other   |            | 0.06396    |            |       |  0.02

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:      131672.0 ave      131672 max      131672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131672
Ave neighs/atom = 65.836000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.949877595353, Press = -0.0561943522768386
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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   -8441.9982   -8441.9982   -8509.8026   -8509.8026    262.40987    262.40987     23367.89     23367.89   -953.86879   -953.86879 
   48000   -8436.8899   -8436.8899   -8507.1382   -8507.1382    271.86811    271.86811    23365.375    23365.375   -250.77521   -250.77521 
Loop time of 266.358 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.324 ns/day, 73.988 hours/ns, 3.754 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    | 265.74     | 265.74     | 265.74     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11022    | 0.11022    | 0.11022    |   0.0 |  0.04
Output  | 0.0001553  | 0.0001553  | 0.0001553  |   0.0 |  0.00
Modify  | 0.43978    | 0.43978    | 0.43978    |   0.0 |  0.17
Other   |            | 0.06347    |            |       |  0.02

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:      131326.0 ave      131326 max      131326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131326
Ave neighs/atom = 65.663000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.935447824346, Press = -0.628231510697948
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   48000   -8436.8899   -8436.8899   -8507.1382   -8507.1382    271.86811    271.86811    23365.375    23365.375   -250.77521   -250.77521 
   49000   -8437.9993   -8437.9993   -8507.2829   -8507.2829    268.13471    268.13471    23351.431    23351.431     619.5845     619.5845 
Loop time of 258.581 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.334 ns/day, 71.828 hours/ns, 3.867 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 257.99     | 257.99     | 257.99     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10654    | 0.10654    | 0.10654    |   0.0 |  0.04
Output  | 0.0001534  | 0.0001534  | 0.0001534  |   0.0 |  0.00
Modify  | 0.42386    | 0.42386    | 0.42386    |   0.0 |  0.16
Other   |            | 0.06405    |            |       |  0.02

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:      131514.0 ave      131514 max      131514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131514
Ave neighs/atom = 65.757000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.884221910192, Press = -0.52936080508117
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   49000   -8437.9993   -8437.9993   -8507.2829   -8507.2829    268.13471    268.13471    23351.431    23351.431     619.5845     619.5845 
   50000   -8436.4737   -8436.4737   -8508.0972   -8508.0972    277.19016    277.19016    23335.219    23335.219    1742.8525    1742.8525 
Loop time of 265.73 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.325 ns/day, 73.814 hours/ns, 3.763 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 265.11     | 265.11     | 265.11     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11016    | 0.11016    | 0.11016    |   0.0 |  0.04
Output  | 0.0001993  | 0.0001993  | 0.0001993  |   0.0 |  0.00
Modify  | 0.44195    | 0.44195    | 0.44195    |   0.0 |  0.17
Other   |            | 0.06414    |            |       |  0.02

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:      131678.0 ave      131678 max      131678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131678
Ave neighs/atom = 65.839000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.94702201896, Press = -0.00562920730132674
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   50000   -8436.4737   -8436.4737   -8508.0972   -8508.0972    277.19016    277.19016    23335.219    23335.219    1742.8525    1742.8525 
   51000   -8435.4565   -8435.4565   -8506.6804   -8506.6804    275.64396    275.64396    23352.632    23352.632    714.71523    714.71523 
Loop time of 266.755 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.324 ns/day, 74.099 hours/ns, 3.749 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 266.14     | 266.14     | 266.14     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11133    | 0.11133    | 0.11133    |   0.0 |  0.04
Output  | 0.00019932 | 0.00019932 | 0.00019932 |   0.0 |  0.00
Modify  | 0.44343    | 0.44343    | 0.44343    |   0.0 |  0.17
Other   |            | 0.06498    |            |       |  0.02

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:      131760.0 ave      131760 max      131760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131760
Ave neighs/atom = 65.880000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.965721916151, Press = 1.97101129481771
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   51000   -8435.4565   -8435.4565   -8506.6804   -8506.6804    275.64396    275.64396    23352.632    23352.632    714.71523    714.71523 
   52000   -8438.5776   -8438.5776   -8508.4895   -8508.4895     270.5662     270.5662    23390.682    23390.682   -2249.4401   -2249.4401 
Loop time of 239.174 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.361 ns/day, 66.437 hours/ns, 4.181 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    | 238.64     | 238.64     | 238.64     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10019    | 0.10019    | 0.10019    |   0.0 |  0.04
Output  | 0.00015569 | 0.00015569 | 0.00015569 |   0.0 |  0.00
Modify  | 0.37548    | 0.37548    | 0.37548    |   0.0 |  0.16
Other   |            | 0.0598     |            |       |  0.03

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:      131822.0 ave      131822 max      131822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131822
Ave neighs/atom = 65.911000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.021557543476, Press = 0.461046166525119
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   52000   -8438.5776   -8438.5776   -8508.4895   -8508.4895     270.5662     270.5662    23390.682    23390.682   -2249.4401   -2249.4401 
   53000   -8434.6623   -8434.6623   -8506.5663   -8506.5663    278.27568    278.27568    23383.169    23383.169   -1371.9779   -1371.9779 
Loop time of 250.513 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.345 ns/day, 69.587 hours/ns, 3.992 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 249.94     | 249.94     | 249.94     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10431    | 0.10431    | 0.10431    |   0.0 |  0.04
Output  | 0.00016043 | 0.00016043 | 0.00016043 |   0.0 |  0.00
Modify  | 0.40644    | 0.40644    | 0.40644    |   0.0 |  0.16
Other   |            | 0.06196    |            |       |  0.02

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:      131314.0 ave      131314 max      131314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131314
Ave neighs/atom = 65.657000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.0275034975, Press = -0.807180604450997
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   53000   -8434.6623   -8434.6623   -8506.5663   -8506.5663    278.27568    278.27568    23383.169    23383.169   -1371.9779   -1371.9779 
   54000   -8436.2475   -8436.2475   -8507.2415   -8507.2415    274.75429    274.75429    23359.252    23359.252    136.52403    136.52403 
Loop time of 238.277 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.363 ns/day, 66.188 hours/ns, 4.197 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    | 237.74     | 237.74     | 237.74     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099585   | 0.099585   | 0.099585   |   0.0 |  0.04
Output  | 0.00015962 | 0.00015962 | 0.00015962 |   0.0 |  0.00
Modify  | 0.37607    | 0.37607    | 0.37607    |   0.0 |  0.16
Other   |            | 0.05923    |            |       |  0.02

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:      131520.0 ave      131520 max      131520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131520
Ave neighs/atom = 65.760000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.032147452892, Press = -1.19639523916763
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   54000   -8436.2475   -8436.2475   -8507.2415   -8507.2415    274.75429    274.75429    23359.252    23359.252    136.52403    136.52403 
   55000   -8438.0953   -8438.0953   -8508.4728   -8508.4728    272.36828    272.36828    23328.488    23328.488    2089.6426    2089.6426 
Loop time of 249.739 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.346 ns/day, 69.372 hours/ns, 4.004 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    | 249.17     | 249.17     | 249.17     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.104      | 0.104      | 0.104      |   0.0 |  0.04
Output  | 0.00015363 | 0.00015363 | 0.00015363 |   0.0 |  0.00
Modify  | 0.40117    | 0.40117    | 0.40117    |   0.0 |  0.16
Other   |            | 0.06096    |            |       |  0.02

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:      131754.0 ave      131754 max      131754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131754
Ave neighs/atom = 65.877000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.991200230635, Press = -0.366756897433495
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   55000   -8438.0953   -8438.0953   -8508.4728   -8508.4728    272.36828    272.36828    23328.488    23328.488    2089.6426    2089.6426 
   56000   -8434.9288   -8434.9288   -8505.9226   -8505.9226    274.75343    274.75343    23339.525    23339.525    1739.8188    1739.8188 
Loop time of 258.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.335 ns/day, 71.731 hours/ns, 3.872 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 257.63     | 257.63     | 257.63     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10872    | 0.10872    | 0.10872    |   0.0 |  0.04
Output  | 0.00023923 | 0.00023923 | 0.00023923 |   0.0 |  0.00
Modify  | 0.42581    | 0.42581    | 0.42581    |   0.0 |  0.16
Other   |            | 0.0632     |            |       |  0.02

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:      131662.0 ave      131662 max      131662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131662
Ave neighs/atom = 65.831000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.038105437249, Press = 0.823223048054211
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   56000   -8434.9288   -8434.9288   -8505.9226   -8505.9226    274.75343    274.75343    23339.525    23339.525    1739.8188    1739.8188 
   57000   -8438.1824   -8438.1824   -8507.6783   -8507.6783    268.95611    268.95611    23382.453    23382.453   -1606.2757   -1606.2757 
Loop time of 265.819 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.325 ns/day, 73.838 hours/ns, 3.762 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 265.2      | 265.2      | 265.2      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11123    | 0.11123    | 0.11123    |   0.0 |  0.04
Output  | 0.00015682 | 0.00015682 | 0.00015682 |   0.0 |  0.00
Modify  | 0.44489    | 0.44489    | 0.44489    |   0.0 |  0.17
Other   |            | 0.06416    |            |       |  0.02

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:      131858.0 ave      131858 max      131858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131858
Ave neighs/atom = 65.929000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.068227127553, Press = 1.58459863968598
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   57000   -8438.1824   -8438.1824   -8507.6783   -8507.6783    268.95611    268.95611    23382.453    23382.453   -1606.2757   -1606.2757 
   58000    -8439.076    -8439.076   -8510.4955   -8510.4955    276.40074    276.40074    23390.162    23390.162   -2496.4891   -2496.4891 
Loop time of 243.412 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.355 ns/day, 67.614 hours/ns, 4.108 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    | 242.86     | 242.86     | 242.86     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10212    | 0.10212    | 0.10212    |   0.0 |  0.04
Output  | 0.00025564 | 0.00025564 | 0.00025564 |   0.0 |  0.00
Modify  | 0.38686    | 0.38686    | 0.38686    |   0.0 |  0.16
Other   |            | 0.06062    |            |       |  0.02

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:      131432.0 ave      131432 max      131432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131432
Ave neighs/atom = 65.716000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.086810334585, Press = -0.376543376274858
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   58000    -8439.076    -8439.076   -8510.4955   -8510.4955    276.40074    276.40074    23390.162    23390.162   -2496.4891   -2496.4891 
   59000    -8437.636    -8437.636   -8508.6438   -8508.6438    274.80731    274.80731     23369.18     23369.18   -772.86091   -772.86091 
Loop time of 264.816 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.326 ns/day, 73.560 hours/ns, 3.776 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 264.2      | 264.2      | 264.2      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11112    | 0.11112    | 0.11112    |   0.0 |  0.04
Output  | 0.00021717 | 0.00021717 | 0.00021717 |   0.0 |  0.00
Modify  | 0.44094    | 0.44094    | 0.44094    |   0.0 |  0.17
Other   |            | 0.06495    |            |       |  0.02

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:      131124.0 ave      131124 max      131124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131124
Ave neighs/atom = 65.562000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.037053317233, Press = -0.844389406035095
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   59000    -8437.636    -8437.636   -8508.6438   -8508.6438    274.80731    274.80731     23369.18     23369.18   -772.86091   -772.86091 
   60000   -8438.4937   -8438.4937   -8506.7887   -8506.7887    264.30887    264.30887    23350.379    23350.379    711.06955    711.06955 
Loop time of 257.127 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.336 ns/day, 71.424 hours/ns, 3.889 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 256.53     | 256.53     | 256.53     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1078     | 0.1078     | 0.1078     |   0.0 |  0.04
Output  | 0.00015748 | 0.00015748 | 0.00015748 |   0.0 |  0.00
Modify  | 0.4218     | 0.4218     | 0.4218     |   0.0 |  0.16
Other   |            | 0.0642     |            |       |  0.02

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:      131514.0 ave      131514 max      131514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131514
Ave neighs/atom = 65.757000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.039898117616, Press = -0.419062124172426
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   60000   -8438.4937   -8438.4937   -8506.7887   -8506.7887    264.30887    264.30887    23350.379    23350.379    711.06955    711.06955 
   61000   -8436.5494   -8436.5494   -8506.6948   -8506.6948    271.47024    271.47024    23344.726    23344.726    1141.5171    1141.5171 
Loop time of 263.477 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.328 ns/day, 73.188 hours/ns, 3.795 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.86     | 262.86     | 262.86     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11072    | 0.11072    | 0.11072    |   0.0 |  0.04
Output  | 0.00021688 | 0.00021688 | 0.00021688 |   0.0 |  0.00
Modify  | 0.43996    | 0.43996    | 0.43996    |   0.0 |  0.17
Other   |            | 0.06507    |            |       |  0.02

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:      131700.0 ave      131700 max      131700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131700
Ave neighs/atom = 65.850000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.03579280541, Press = 0.295720419119804
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   61000   -8436.5494   -8436.5494   -8506.6948   -8506.6948    271.47024    271.47024    23344.726    23344.726    1141.5171    1141.5171 
   62000   -8436.1426   -8436.1426   -8506.9345   -8506.9345    273.97223    273.97223    23378.471    23378.471   -1133.4533   -1133.4533 
Loop time of 263.644 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.328 ns/day, 73.235 hours/ns, 3.793 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    | 263.03     | 263.03     | 263.03     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11179    | 0.11179    | 0.11179    |   0.0 |  0.04
Output  | 0.00015533 | 0.00015533 | 0.00015533 |   0.0 |  0.00
Modify  | 0.44084    | 0.44084    | 0.44084    |   0.0 |  0.17
Other   |            | 0.06391    |            |       |  0.02

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:      131690.0 ave      131690 max      131690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131690
Ave neighs/atom = 65.845000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.035654381374, Press = 1.17980572691923
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      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 
   62000   -8436.1426   -8436.1426   -8506.9345   -8506.9345    273.97223    273.97223    23378.471    23378.471   -1133.4533   -1133.4533 
   63000   -8438.6557   -8438.6557   -8507.6527   -8507.6527    267.02538    267.02538    23401.307    23401.307   -2908.2055   -2908.2055 
Loop time of 230.226 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.952 hours/ns, 4.344 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    | 229.71     | 229.71     | 229.71     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098632   | 0.098632   | 0.098632   |   0.0 |  0.04
Output  | 0.00015558 | 0.00015558 | 0.00015558 |   0.0 |  0.00
Modify  | 0.35486    | 0.35486    | 0.35486    |   0.0 |  0.15
Other   |            | 0.05806    |            |       |  0.03

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:      131470.0 ave      131470 max      131470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0