# 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.004 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_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 253.15*${_u_temperature}
variable temp_converted equal 253.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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   -8515.2661   -8515.2661   -8580.6777   -8580.6777       253.15       253.15    23155.049    23155.049    3017.3681    3017.3681 
    1000   -8448.0954   -8448.0954   -8511.4817   -8511.4817    245.31128    245.31128    23385.632    23385.632   -2768.1037   -2768.1037 
Loop time of 261.382 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.606 hours/ns, 3.826 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    | 260.81     | 260.81     | 260.81     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10554    | 0.10554    | 0.10554    |   0.0 |  0.04
Output  | 0.00030111 | 0.00030111 | 0.00030111 |   0.0 |  0.00
Modify  | 0.4046     | 0.4046     | 0.4046     |   0.0 |  0.15
Other   |            | 0.06526    |            |       |  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   -8448.0954   -8448.0954   -8511.4817   -8511.4817    245.31128    245.31128    23385.632    23385.632   -2768.1037   -2768.1037 
    2000   -8447.2073   -8447.2073   -8511.2036   -8511.2036    247.67221    247.67221    23343.921    23343.921    254.50231    254.50231 
Loop time of 263.128 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.328 ns/day, 73.091 hours/ns, 3.800 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.55     | 262.55     | 262.55     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10477    | 0.10477    | 0.10477    |   0.0 |  0.04
Output  | 0.00020409 | 0.00020409 | 0.00020409 |   0.0 |  0.00
Modify  | 0.40777    | 0.40777    | 0.40777    |   0.0 |  0.15
Other   |            | 0.06545    |            |       |  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:      131490.0 ave      131490 max      131490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131490
Ave neighs/atom = 65.745000
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   -8447.2073   -8447.2073   -8511.2036   -8511.2036    247.67221    247.67221    23343.921    23343.921    254.50231    254.50231 
    3000   -8449.2663   -8449.2663   -8516.7611   -8516.7611    261.21165    261.21165    23340.388    23340.388   -153.87492   -153.87492 
Loop time of 268.88 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.321 ns/day, 74.689 hours/ns, 3.719 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    | 268.26     | 268.26     | 268.26     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11007    | 0.11007    | 0.11007    |   0.0 |  0.04
Output  | 0.00021974 | 0.00021974 | 0.00021974 |   0.0 |  0.00
Modify  | 0.43719    | 0.43719    | 0.43719    |   0.0 |  0.16
Other   |            | 0.06845    |            |       |  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:      131352.0 ave      131352 max      131352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131352
Ave neighs/atom = 65.676000
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   -8449.2663   -8449.2663   -8516.7611   -8516.7611    261.21165    261.21165    23340.388    23340.388   -153.87492   -153.87492 
    4000   -8446.7489   -8446.7489   -8509.5269   -8509.5269    242.95732    242.95732    23360.774    23360.774   -732.25677   -732.25677 
Loop time of 245.67 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.352 ns/day, 68.242 hours/ns, 4.071 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    | 245.13     | 245.13     | 245.13     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10016    | 0.10016    | 0.10016    |   0.0 |  0.04
Output  | 0.00019316 | 0.00019316 | 0.00019316 |   0.0 |  0.00
Modify  | 0.3716     | 0.3716     | 0.3716     |   0.0 |  0.15
Other   |            | 0.06338    |            |       |  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:      130978.0 ave      130978 max      130978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130978
Ave neighs/atom = 65.489000
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   -8446.7489   -8446.7489   -8509.5269   -8509.5269    242.95732    242.95732    23360.774    23360.774   -732.25677   -732.25677 
    5000   -8449.1581   -8449.1581   -8515.9525   -8515.9525    258.50139    258.50139    23322.815    23322.815    1229.9011    1229.9011 
Loop time of 243.237 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.355 ns/day, 67.566 hours/ns, 4.111 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.71     | 242.71     | 242.71     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098844   | 0.098844   | 0.098844   |   0.0 |  0.04
Output  | 0.00015704 | 0.00015704 | 0.00015704 |   0.0 |  0.00
Modify  | 0.36535    | 0.36535    | 0.36535    |   0.0 |  0.15
Other   |            | 0.06182    |            |       |  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:      131490.0 ave      131490 max      131490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131490
Ave neighs/atom = 65.745000
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 = 250.926647938141, Press = -193.641723234244
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   -8449.1581   -8449.1581   -8515.9525   -8515.9525    258.50139    258.50139    23322.815    23322.815    1229.9011    1229.9011 
    6000   -8447.2421   -8447.2421   -8513.0631   -8513.0631    254.73398    254.73398    23370.219    23370.219   -1638.0995   -1638.0995 
Loop time of 231.411 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.281 hours/ns, 4.321 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    | 230.9      | 230.9      | 230.9      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09471    | 0.09471    | 0.09471    |   0.0 |  0.04
Output  | 0.00015375 | 0.00015375 | 0.00015375 |   0.0 |  0.00
Modify  | 0.35333    | 0.35333    | 0.35333    |   0.0 |  0.15
Other   |            | 0.05931    |            |       |  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:      130998.0 ave      130998 max      130998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130998
Ave neighs/atom = 65.499000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.650161175628, Press = 12.8024289050525
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   -8447.2421   -8447.2421   -8513.0631   -8513.0631    254.73398    254.73398    23370.219    23370.219   -1638.0995   -1638.0995 
    7000   -8448.3137   -8448.3137   -8514.9982   -8514.9982    258.07568    258.07568    23333.408    23333.408    613.78421    613.78421 
Loop time of 253.761 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.340 ns/day, 70.489 hours/ns, 3.941 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    | 253.19     | 253.19     | 253.19     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10293    | 0.10293    | 0.10293    |   0.0 |  0.04
Output  | 0.00018657 | 0.00018657 | 0.00018657 |   0.0 |  0.00
Modify  | 0.40881    | 0.40881    | 0.40881    |   0.0 |  0.16
Other   |            | 0.06347    |            |       |  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:      131228.0 ave      131228 max      131228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131228
Ave neighs/atom = 65.614000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.020154345995, Press = -52.6067286181535
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   -8448.3137   -8448.3137   -8514.9982   -8514.9982    258.07568    258.07568    23333.408    23333.408    613.78421    613.78421 
    8000   -8449.3487   -8449.3487   -8512.6115   -8512.6115    244.83357    244.83357    23335.525    23335.525    676.24928    676.24928 
Loop time of 267.825 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.323 ns/day, 74.396 hours/ns, 3.734 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    | 267.21     | 267.21     | 267.21     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10816    | 0.10816    | 0.10816    |   0.0 |  0.04
Output  | 0.00019591 | 0.00019591 | 0.00019591 |   0.0 |  0.00
Modify  | 0.44273    | 0.44273    | 0.44273    |   0.0 |  0.17
Other   |            | 0.06678    |            |       |  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:      131206.0 ave      131206 max      131206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131206
Ave neighs/atom = 65.603000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.09616009283, Press = 13.8839003066029
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   -8449.3487   -8449.3487   -8512.6115   -8512.6115    244.83357    244.83357    23335.525    23335.525    676.24928    676.24928 
    9000   -8447.0666   -8447.0666   -8512.2432   -8512.2432    252.23994    252.23994    23361.453    23361.453   -1104.6354   -1104.6354 
Loop time of 268.571 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.322 ns/day, 74.603 hours/ns, 3.723 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    | 267.95     | 267.95     | 267.95     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10783    | 0.10783    | 0.10783    |   0.0 |  0.04
Output  | 0.000159   | 0.000159   | 0.000159   |   0.0 |  0.00
Modify  | 0.443      | 0.443      | 0.443      |   0.0 |  0.16
Other   |            | 0.0666     |            |       |  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:      131276.0 ave      131276 max      131276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131276
Ave neighs/atom = 65.638000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 251.700084339898, Press = -12.4170971268492
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   -8447.0666   -8447.0666   -8512.2432   -8512.2432    252.23994    252.23994    23361.453    23361.453   -1104.6354   -1104.6354 
   10000   -8449.0321   -8449.0321   -8513.1355   -8513.1355    248.08697    248.08697    23319.799    23319.799    1687.8779    1687.8779 
Loop time of 260.726 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.424 hours/ns, 3.835 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.13     | 260.13     | 260.13     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10478    | 0.10478    | 0.10478    |   0.0 |  0.04
Output  | 0.0001564  | 0.0001564  | 0.0001564  |   0.0 |  0.00
Modify  | 0.42504    | 0.42504    | 0.42504    |   0.0 |  0.16
Other   |            | 0.06436    |            |       |  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 = 252.000692588287, Press = 0.725162035924074
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   -8449.0321   -8449.0321   -8513.1355   -8513.1355    248.08697    248.08697    23319.799    23319.799    1687.8779    1687.8779 
   11000   -8445.6785   -8445.6785   -8511.7565   -8511.7565    255.72862    255.72862     23371.77     23371.77   -1602.5534   -1602.5534 
Loop time of 245.808 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.351 ns/day, 68.280 hours/ns, 4.068 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    | 245.26     | 245.26     | 245.26     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099557   | 0.099557   | 0.099557   |   0.0 |  0.04
Output  | 0.00015354 | 0.00015354 | 0.00015354 |   0.0 |  0.00
Modify  | 0.39098    | 0.39098    | 0.39098    |   0.0 |  0.16
Other   |            | 0.06222    |            |       |  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:      131404.0 ave      131404 max      131404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131404
Ave neighs/atom = 65.702000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.590859042296, Press = -3.56590361370047
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   -8445.6785   -8445.6785   -8511.7565   -8511.7565    255.72862    255.72862     23371.77     23371.77   -1602.5534   -1602.5534 
   12000   -8448.1674   -8448.1674   -8514.7548   -8514.7548     257.7001     257.7001    23324.967    23324.967    1319.8497    1319.8497 
Loop time of 239.955 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.360 ns/day, 66.654 hours/ns, 4.167 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    | 239.42     | 239.42     | 239.42     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097279   | 0.097279   | 0.097279   |   0.0 |  0.04
Output  | 0.00015724 | 0.00015724 | 0.00015724 |   0.0 |  0.00
Modify  | 0.3736     | 0.3736     | 0.3736     |   0.0 |  0.16
Other   |            | 0.06162    |            |       |  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:      131084.0 ave      131084 max      131084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131084
Ave neighs/atom = 65.542000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.77091101086, Press = -4.33392781146505
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   -8448.1674   -8448.1674   -8514.7548   -8514.7548     257.7001     257.7001    23324.967    23324.967    1319.8497    1319.8497 
   13000   -8444.7768   -8444.7768    -8514.093    -8514.093    268.26097    268.26097     23377.99     23377.99   -2298.6682   -2298.6682 
Loop time of 252.679 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.342 ns/day, 70.189 hours/ns, 3.958 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    | 252.11     | 252.11     | 252.11     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10229    | 0.10229    | 0.10229    |   0.0 |  0.04
Output  | 0.00015759 | 0.00015759 | 0.00015759 |   0.0 |  0.00
Modify  | 0.40229    | 0.40229    | 0.40229    |   0.0 |  0.16
Other   |            | 0.06445    |            |       |  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:      131394.0 ave      131394 max      131394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131394
Ave neighs/atom = 65.697000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.108394032774, Press = 0.997116224040912
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   -8444.7768   -8444.7768    -8514.093    -8514.093    268.26097    268.26097     23377.99     23377.99   -2298.6682   -2298.6682 
   14000   -8447.1761   -8447.1761    -8512.585    -8512.585      253.139      253.139    23329.769    23329.769     1225.972     1225.972 
Loop time of 256.928 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.336 ns/day, 71.369 hours/ns, 3.892 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    | 256.34     | 256.34     | 256.34     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10434    | 0.10434    | 0.10434    |   0.0 |  0.04
Output  | 0.00015507 | 0.00015507 | 0.00015507 |   0.0 |  0.00
Modify  | 0.41848    | 0.41848    | 0.41848    |   0.0 |  0.16
Other   |            | 0.06454    |            |       |  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:      130978.0 ave      130978 max      130978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130978
Ave neighs/atom = 65.489000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.066021261573, Press = -6.33835171270598
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   -8447.1761   -8447.1761    -8512.585    -8512.585      253.139      253.139    23329.769    23329.769     1225.972     1225.972 
   15000   -8451.6904   -8451.6904   -8513.2906   -8513.2906    238.39882    238.39882    23339.911    23339.911    164.74996    164.74996 
Loop time of 259.883 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.332 ns/day, 72.190 hours/ns, 3.848 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    | 259.28     | 259.28     | 259.28     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10592    | 0.10592    | 0.10592    |   0.0 |  0.04
Output  | 0.00046669 | 0.00046669 | 0.00046669 |   0.0 |  0.00
Modify  | 0.42757    | 0.42757    | 0.42757    |   0.0 |  0.16
Other   |            | 0.06581    |            |       |  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 = 252.982319401304, Press = 4.75352110824671
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   -8451.6904   -8451.6904   -8513.2906   -8513.2906    238.39882    238.39882    23339.911    23339.911    164.74996    164.74996 
   16000   -8446.1154   -8446.1154   -8512.9668   -8512.9668    258.72161    258.72161    23364.214    23364.214   -1161.4841   -1161.4841 
Loop time of 253.555 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.341 ns/day, 70.432 hours/ns, 3.944 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.98     | 252.98     | 252.98     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10272    | 0.10272    | 0.10272    |   0.0 |  0.04
Output  | 0.00025831 | 0.00025831 | 0.00025831 |   0.0 |  0.00
Modify  | 0.40594    | 0.40594    | 0.40594    |   0.0 |  0.16
Other   |            | 0.06412    |            |       |  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:      131164.0 ave      131164 max      131164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131164
Ave neighs/atom = 65.582000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.821904535481, Press = -3.79461099630382
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   -8446.1154   -8446.1154   -8512.9668   -8512.9668    258.72161    258.72161    23364.214    23364.214   -1161.4841   -1161.4841 
   17000    -8447.656    -8447.656   -8512.9395   -8512.9395    252.65406    252.65406    23334.494    23334.494    858.76271    858.76271 
Loop time of 249.633 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.346 ns/day, 69.342 hours/ns, 4.006 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.08     | 249.08     | 249.08     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099747   | 0.099747   | 0.099747   |   0.0 |  0.04
Output  | 0.00015564 | 0.00015564 | 0.00015564 |   0.0 |  0.00
Modify  | 0.39       | 0.39       | 0.39       |   0.0 |  0.16
Other   |            | 0.06302    |            |       |  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:      131130.0 ave      131130 max      131130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131130
Ave neighs/atom = 65.565000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.006078685879, Press = -0.402568246679262
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    -8447.656    -8447.656   -8512.9395   -8512.9395    252.65406    252.65406    23334.494    23334.494    858.76271    858.76271 
   18000   -8449.6819   -8449.6819   -8515.8058   -8515.8058    255.90637    255.90637    23353.654    23353.654   -942.66753   -942.66753 
Loop time of 239.485 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.361 ns/day, 66.524 hours/ns, 4.176 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.96     | 238.96     | 238.96     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09678    | 0.09678    | 0.09678    |   0.0 |  0.04
Output  | 0.00019915 | 0.00019915 | 0.00019915 |   0.0 |  0.00
Modify  | 0.36961    | 0.36961    | 0.36961    |   0.0 |  0.15
Other   |            | 0.06189    |            |       |  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:      131238.0 ave      131238 max      131238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131238
Ave neighs/atom = 65.619000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.031409712379, Press = -2.06855609882029
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   -8449.6819   -8449.6819   -8515.8058   -8515.8058    255.90637    255.90637    23353.654    23353.654   -942.66753   -942.66753 
   19000   -8445.3815   -8445.3815   -8511.9115   -8511.9115     257.4781     257.4781     23324.55     23324.55    1678.7015    1678.7015 
Loop time of 267.145 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.323 ns/day, 74.207 hours/ns, 3.743 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.53     | 266.53     | 266.53     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10681    | 0.10681    | 0.10681    |   0.0 |  0.04
Output  | 0.0001557  | 0.0001557  | 0.0001557  |   0.0 |  0.00
Modify  | 0.43861    | 0.43861    | 0.43861    |   0.0 |  0.16
Other   |            | 0.06681    |            |       |  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:      131006.0 ave      131006 max      131006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131006
Ave neighs/atom = 65.503000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.094079420037, Press = -1.72364042246425
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   -8445.3815   -8445.3815   -8511.9115   -8511.9115     257.4781     257.4781     23324.55     23324.55    1678.7015    1678.7015 
   20000   -8446.5726   -8446.5726   -8512.5575   -8512.5575    255.36872    255.36872    23386.688    23386.688   -2789.0888   -2789.0888 
Loop time of 268.193 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.322 ns/day, 74.498 hours/ns, 3.729 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    | 267.57     | 267.57     | 267.57     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10745    | 0.10745    | 0.10745    |   0.0 |  0.04
Output  | 0.00015605 | 0.00015605 | 0.00015605 |   0.0 |  0.00
Modify  | 0.44284    | 0.44284    | 0.44284    |   0.0 |  0.17
Other   |            | 0.0677     |            |       |  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:      131504.0 ave      131504 max      131504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131504
Ave neighs/atom = 65.752000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.369361734571, Press = 0.995546065611437
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   -8446.5726   -8446.5726   -8512.5575   -8512.5575    255.36872    255.36872    23386.688    23386.688   -2789.0888   -2789.0888 
   21000    -8447.668    -8447.668   -8515.1881   -8515.1881    261.31007    261.31007    23321.167    23321.167    1545.2265    1545.2265 
Loop time of 267.69 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.323 ns/day, 74.358 hours/ns, 3.736 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    | 267.07     | 267.07     | 267.07     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10769    | 0.10769    | 0.10769    |   0.0 |  0.04
Output  | 0.00019815 | 0.00019815 | 0.00019815 |   0.0 |  0.00
Modify  | 0.44487    | 0.44487    | 0.44487    |   0.0 |  0.17
Other   |            | 0.06657    |            |       |  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:      130960.0 ave      130960 max      130960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130960
Ave neighs/atom = 65.480000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.374325826757, Press = -5.82064560828232
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    -8447.668    -8447.668   -8515.1881   -8515.1881    261.31007    261.31007    23321.167    23321.167    1545.2265    1545.2265 
   22000   -8447.6945   -8447.6945     -8513.38     -8513.38    254.20956    254.20956    23342.744    23342.744     230.5237     230.5237 
Loop time of 268.541 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.322 ns/day, 74.595 hours/ns, 3.724 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    | 267.92     | 267.92     | 267.92     |   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.00015229 | 0.00015229 | 0.00015229 |   0.0 |  0.00
Modify  | 0.44369    | 0.44369    | 0.44369    |   0.0 |  0.17
Other   |            | 0.06696    |            |       |  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:      131222.0 ave      131222 max      131222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131222
Ave neighs/atom = 65.611000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.426923702711, Press = 2.38526437795739
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   -8447.6945   -8447.6945     -8513.38     -8513.38    254.20956    254.20956    23342.744    23342.744     230.5237     230.5237 
   23000    -8448.526    -8448.526   -8513.4095   -8513.4095    251.10599    251.10599    23366.088    23366.088   -1437.8619   -1437.8619 
Loop time of 268.758 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.321 ns/day, 74.655 hours/ns, 3.721 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    | 268.14     | 268.14     | 268.14     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10764    | 0.10764    | 0.10764    |   0.0 |  0.04
Output  | 0.00021506 | 0.00021506 | 0.00021506 |   0.0 |  0.00
Modify  | 0.44055    | 0.44055    | 0.44055    |   0.0 |  0.16
Other   |            | 0.06683    |            |       |  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 = 253.33460766349, Press = -2.90589465573318
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    -8448.526    -8448.526   -8513.4095   -8513.4095    251.10599    251.10599    23366.088    23366.088   -1437.8619   -1437.8619 
   24000   -8447.1357   -8447.1357   -8512.8196   -8512.8196    254.20367    254.20367    23318.921    23318.921    2085.0674    2085.0674 
Loop time of 247.192 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.350 ns/day, 68.664 hours/ns, 4.045 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    | 246.64     | 246.64     | 246.64     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099943   | 0.099943   | 0.099943   |   0.0 |  0.04
Output  | 0.0001552  | 0.0001552  | 0.0001552  |   0.0 |  0.00
Modify  | 0.38973    | 0.38973    | 0.38973    |   0.0 |  0.16
Other   |            | 0.06268    |            |       |  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:      131084.0 ave      131084 max      131084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131084
Ave neighs/atom = 65.542000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.391097337186, Press = 0.186457905962392
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   -8447.1357   -8447.1357   -8512.8196   -8512.8196    254.20367    254.20367    23318.921    23318.921    2085.0674    2085.0674 
   25000   -8450.3129   -8450.3129   -8513.8641   -8513.8641    245.94958    245.94958    23379.649    23379.649   -2506.1855   -2506.1855 
Loop time of 231.806 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.391 hours/ns, 4.314 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    | 231.3      | 231.3      | 231.3      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095242   | 0.095242   | 0.095242   |   0.0 |  0.04
Output  | 0.00015832 | 0.00015832 | 0.00015832 |   0.0 |  0.00
Modify  | 0.35203    | 0.35203    | 0.35203    |   0.0 |  0.15
Other   |            | 0.05898    |            |       |  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:      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 = 253.325514962225, Press = -0.624934037794774
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   -8450.3129   -8450.3129   -8513.8641   -8513.8641    245.94958    245.94958    23379.649    23379.649   -2506.1855   -2506.1855 
   26000   -8445.9796   -8445.9796   -8511.8575   -8511.8575    254.95428    254.95428    23327.746    23327.746    1510.7714    1510.7714 
Loop time of 243.38 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.355 ns/day, 67.606 hours/ns, 4.109 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    | 242.84     | 242.84     | 242.84     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098206   | 0.098206   | 0.098206   |   0.0 |  0.04
Output  | 0.0001537  | 0.0001537  | 0.0001537  |   0.0 |  0.00
Modify  | 0.37628    | 0.37628    | 0.37628    |   0.0 |  0.15
Other   |            | 0.06218    |            |       |  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:      130904.0 ave      130904 max      130904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130904
Ave neighs/atom = 65.452000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.327416185185, Press = -1.72564826151868
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   -8445.9796   -8445.9796   -8511.8575   -8511.8575    254.95428    254.95428    23327.746    23327.746    1510.7714    1510.7714 
   27000   -8448.7854   -8448.7854   -8512.1644   -8512.1644    245.28336    245.28336    23348.235    23348.235   -53.372383   -53.372383 
Loop time of 239.309 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.361 ns/day, 66.475 hours/ns, 4.179 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    | 238.78     | 238.78     | 238.78     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097666   | 0.097666   | 0.097666   |   0.0 |  0.04
Output  | 0.00015143 | 0.00015143 | 0.00015143 |   0.0 |  0.00
Modify  | 0.36963    | 0.36963    | 0.36963    |   0.0 |  0.15
Other   |            | 0.06156    |            |       |  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:      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 = 253.370134124878, Press = 0.475539057807833
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   -8448.7854   -8448.7854   -8512.1644   -8512.1644    245.28336    245.28336    23348.235    23348.235   -53.372383   -53.372383 
   28000   -8445.2926   -8445.2926   -8511.1823   -8511.1823    254.99998    254.99998    23348.718    23348.718     143.5897     143.5897 
Loop time of 256.914 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.336 ns/day, 71.365 hours/ns, 3.892 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    | 256.33     | 256.33     | 256.33     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10417    | 0.10417    | 0.10417    |   0.0 |  0.04
Output  | 0.00015588 | 0.00015588 | 0.00015588 |   0.0 |  0.00
Modify  | 0.4151     | 0.4151     | 0.4151     |   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:      131156.0 ave      131156 max      131156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131156
Ave neighs/atom = 65.578000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.458381802165, Press = -1.78687888010815
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   -8445.2926   -8445.2926   -8511.1823   -8511.1823    254.99998    254.99998    23348.718    23348.718     143.5897     143.5897 
   29000    -8450.126    -8450.126   -8512.9617   -8512.9617    243.18089    243.18089     23333.87     23333.87     736.4617     736.4617 
Loop time of 253.739 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.341 ns/day, 70.483 hours/ns, 3.941 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    | 253.17     | 253.17     | 253.17     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10305    | 0.10305    | 0.10305    |   0.0 |  0.04
Output  | 0.00020219 | 0.00020219 | 0.00020219 |   0.0 |  0.00
Modify  | 0.40677    | 0.40677    | 0.40677    |   0.0 |  0.16
Other   |            | 0.06411    |            |       |  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:      131288.0 ave      131288 max      131288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131288
Ave neighs/atom = 65.644000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.469241155281, Press = 0.36337390442099
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    -8450.126    -8450.126   -8512.9617   -8512.9617    243.18089    243.18089     23333.87     23333.87     736.4617     736.4617 
   30000   -8448.0598   -8448.0598   -8512.8203   -8512.8203    250.62974    250.62974    23375.814    23375.814    -2049.121    -2049.121 
Loop time of 268.597 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.322 ns/day, 74.610 hours/ns, 3.723 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    | 267.98     | 267.98     | 267.98     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10959    | 0.10959    | 0.10959    |   0.0 |  0.04
Output  | 0.00022061 | 0.00022061 | 0.00022061 |   0.0 |  0.00
Modify  | 0.44428    | 0.44428    | 0.44428    |   0.0 |  0.17
Other   |            | 0.06676    |            |       |  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:      131442.0 ave      131442 max      131442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131442
Ave neighs/atom = 65.721000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.451113744836, Press = -2.27199484136592
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   -8448.0598   -8448.0598   -8512.8203   -8512.8203    250.62974    250.62974    23375.814    23375.814    -2049.121    -2049.121 
   31000   -8447.0904   -8447.0904   -8513.3264   -8513.3264    256.34036    256.34036     23300.11     23300.11    3224.1474    3224.1474 
Loop time of 267.8 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.323 ns/day, 74.389 hours/ns, 3.734 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    | 267.18     | 267.18     | 267.18     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10846    | 0.10846    | 0.10846    |   0.0 |  0.04
Output  | 0.00019555 | 0.00019555 | 0.00019555 |   0.0 |  0.00
Modify  | 0.44027    | 0.44027    | 0.44027    |   0.0 |  0.16
Other   |            | 0.06712    |            |       |  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:      131092.0 ave      131092 max      131092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131092
Ave neighs/atom = 65.546000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.459953935075, Press = -0.0903763344433258
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   -8447.0904   -8447.0904   -8513.3264   -8513.3264    256.34036    256.34036     23300.11     23300.11    3224.1474    3224.1474 
   32000    -8444.447    -8444.447   -8511.7618   -8511.7618    260.51533    260.51533    23382.081    23382.081   -2192.5875   -2192.5875 
Loop time of 267.97 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.322 ns/day, 74.436 hours/ns, 3.732 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    | 267.36     | 267.36     | 267.36     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10626    | 0.10626    | 0.10626    |   0.0 |  0.04
Output  | 0.00019679 | 0.00019679 | 0.00019679 |   0.0 |  0.00
Modify  | 0.43516    | 0.43516    | 0.43516    |   0.0 |  0.16
Other   |            | 0.06629    |            |       |  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 = 253.479495987433, Press = 0.452426166404707
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    -8444.447    -8444.447   -8511.7618   -8511.7618    260.51533    260.51533    23382.081    23382.081   -2192.5875   -2192.5875 
   33000   -8446.9223   -8446.9223   -8512.4114   -8512.4114    253.44983    253.44983    23327.456    23327.456    1370.5068    1370.5068 
Loop time of 260.963 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.490 hours/ns, 3.832 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    | 260.36     | 260.36     | 260.36     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10544    | 0.10544    | 0.10544    |   0.0 |  0.04
Output  | 0.00019101 | 0.00019101 | 0.00019101 |   0.0 |  0.00
Modify  | 0.42893    | 0.42893    | 0.42893    |   0.0 |  0.16
Other   |            | 0.06646    |            |       |  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:      131134.0 ave      131134 max      131134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131134
Ave neighs/atom = 65.567000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.480715325472, Press = -1.798649982316
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   -8446.9223   -8446.9223   -8512.4114   -8512.4114    253.44983    253.44983    23327.456    23327.456    1370.5068    1370.5068 
   34000   -8449.8613   -8449.8613   -8514.4631   -8514.4631    250.01576    250.01576    23349.715    23349.715   -517.57844   -517.57844 
Loop time of 268.124 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.322 ns/day, 74.479 hours/ns, 3.730 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    | 267.51     | 267.51     | 267.51     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10764    | 0.10764    | 0.10764    |   0.0 |  0.04
Output  | 0.00015425 | 0.00015425 | 0.00015425 |   0.0 |  0.00
Modify  | 0.44269    | 0.44269    | 0.44269    |   0.0 |  0.17
Other   |            | 0.06655    |            |       |  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:      131324.0 ave      131324 max      131324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131324
Ave neighs/atom = 65.662000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.410758990354, Press = 0.244038610104643
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   -8449.8613   -8449.8613   -8514.4631   -8514.4631    250.01576    250.01576    23349.715    23349.715   -517.57844   -517.57844 
   35000   -8449.2091   -8449.2091   -8514.2247   -8514.2247    251.61698    251.61698    23345.637    23345.637   -196.91557   -196.91557 
Loop time of 235.52 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.367 ns/day, 65.422 hours/ns, 4.246 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        | 235        | 235        |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095704   | 0.095704   | 0.095704   |   0.0 |  0.04
Output  | 0.00015428 | 0.00015428 | 0.00015428 |   0.0 |  0.00
Modify  | 0.36284    | 0.36284    | 0.36284    |   0.0 |  0.15
Other   |            | 0.06007    |            |       |  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:      131274.0 ave      131274 max      131274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131274
Ave neighs/atom = 65.637000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.420524111352, Press = -1.06485232550319
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   -8449.2091   -8449.2091   -8514.2247   -8514.2247    251.61698    251.61698    23345.637    23345.637   -196.91557   -196.91557 
   36000    -8446.957    -8446.957    -8512.335    -8512.335    253.01946    253.01946    23344.265    23344.265    248.96063    248.96063 
Loop time of 254.313 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.340 ns/day, 70.642 hours/ns, 3.932 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    | 253.73     | 253.73     | 253.73     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10345    | 0.10345    | 0.10345    |   0.0 |  0.04
Output  | 0.00015449 | 0.00015449 | 0.00015449 |   0.0 |  0.00
Modify  | 0.41431    | 0.41431    | 0.41431    |   0.0 |  0.16
Other   |            | 0.06434    |            |       |  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:      131146.0 ave      131146 max      131146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131146
Ave neighs/atom = 65.573000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.435423808803, Press = -0.63883496305767
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    -8446.957    -8446.957    -8512.335    -8512.335    253.01946    253.01946    23344.265    23344.265    248.96063    248.96063 
   37000   -8452.4246   -8452.4246   -8516.2189   -8516.2189    246.89053    246.89053    23340.248    23340.248   -114.13171   -114.13171 
Loop time of 267.738 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.323 ns/day, 74.372 hours/ns, 3.735 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    | 267.12     | 267.12     | 267.12     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10764    | 0.10764    | 0.10764    |   0.0 |  0.04
Output  | 0.0002141  | 0.0002141  | 0.0002141  |   0.0 |  0.00
Modify  | 0.44499    | 0.44499    | 0.44499    |   0.0 |  0.17
Other   |            | 0.06657    |            |       |  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:      131192.0 ave      131192 max      131192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131192
Ave neighs/atom = 65.596000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.403894675528, Press = -0.161275505118632
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   -8452.4246   -8452.4246   -8516.2189   -8516.2189    246.89053    246.89053    23340.248    23340.248   -114.13171   -114.13171 
   38000   -8446.1383   -8446.1383   -8511.7078   -8511.7078    253.76063    253.76063    23345.247    23345.247    291.62275    291.62275 
Loop time of 261.273 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.576 hours/ns, 3.827 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    | 260.67     | 260.67     | 260.67     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10545    | 0.10545    | 0.10545    |   0.0 |  0.04
Output  | 0.00015338 | 0.00015338 | 0.00015338 |   0.0 |  0.00
Modify  | 0.42792    | 0.42792    | 0.42792    |   0.0 |  0.16
Other   |            | 0.06545    |            |       |  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:      130970.0 ave      130970 max      130970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130970
Ave neighs/atom = 65.485000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.354060246999, Press = -2.25195645712319
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   -8446.1383   -8446.1383   -8511.7078   -8511.7078    253.76063    253.76063    23345.247    23345.247    291.62275    291.62275 
   39000   -8448.7075   -8448.7075   -8514.4827   -8514.4827    254.55673    254.55673    23334.798    23334.798    572.88752    572.88752 
Loop time of 263.217 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.328 ns/day, 73.116 hours/ns, 3.799 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.6      | 262.6      | 262.6      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10794    | 0.10794    | 0.10794    |   0.0 |  0.04
Output  | 0.0001948  | 0.0001948  | 0.0001948  |   0.0 |  0.00
Modify  | 0.44245    | 0.44245    | 0.44245    |   0.0 |  0.17
Other   |            | 0.067      |            |       |  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:      131228.0 ave      131228 max      131228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131228
Ave neighs/atom = 65.614000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.393548707583, Press = 1.70473406258202
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   -8448.7075   -8448.7075   -8514.4827   -8514.4827    254.55673    254.55673    23334.798    23334.798    572.88752    572.88752 
   40000   -8448.9016   -8448.9016   -8513.2933   -8513.2933     249.2026     249.2026    23367.004    23367.004   -1513.4356   -1513.4356 
Loop time of 251.954 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.343 ns/day, 69.987 hours/ns, 3.969 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    | 251.38     | 251.38     | 251.38     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10173    | 0.10173    | 0.10173    |   0.0 |  0.04
Output  | 0.00018322 | 0.00018322 | 0.00018322 |   0.0 |  0.00
Modify  | 0.40545    | 0.40545    | 0.40545    |   0.0 |  0.16
Other   |            | 0.06406    |            |       |  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:      131214.0 ave      131214 max      131214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131214
Ave neighs/atom = 65.607000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.433438782182, Press = -2.15658077815599
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   -8448.9016   -8448.9016   -8513.2933   -8513.2933     249.2026     249.2026    23367.004    23367.004   -1513.4356   -1513.4356 
   41000   -8448.2054   -8448.2054   -8513.8879   -8513.8879    254.19817    254.19817    23321.782    23321.782    1531.4766    1531.4766 
Loop time of 268.592 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.322 ns/day, 74.609 hours/ns, 3.723 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    | 267.96     | 267.96     | 267.96     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1093     | 0.1093     | 0.1093     |   0.0 |  0.04
Output  | 0.00047664 | 0.00047664 | 0.00047664 |   0.0 |  0.00
Modify  | 0.45162    | 0.45162    | 0.45162    |   0.0 |  0.17
Other   |            | 0.06672    |            |       |  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:      130924.0 ave      130924 max      130924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130924
Ave neighs/atom = 65.462000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.421004624447, Press = 0.128225963917676
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   -8448.2054   -8448.2054   -8513.8879   -8513.8879    254.19817    254.19817    23321.782    23321.782    1531.4766    1531.4766 
   42000    -8448.487    -8448.487   -8513.1061   -8513.1061    250.08263    250.08263    23365.722    23365.722    -1407.224    -1407.224 
Loop time of 266.228 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.325 ns/day, 73.952 hours/ns, 3.756 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.61     | 265.61     | 265.61     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10815    | 0.10815    | 0.10815    |   0.0 |  0.04
Output  | 0.00015448 | 0.00015448 | 0.00015448 |   0.0 |  0.00
Modify  | 0.44067    | 0.44067    | 0.44067    |   0.0 |  0.17
Other   |            | 0.06647    |            |       |  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:      131298.0 ave      131298 max      131298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131298
Ave neighs/atom = 65.649000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.403578211442, Press = -0.560520810755345
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    -8448.487    -8448.487   -8513.1061   -8513.1061    250.08263    250.08263    23365.722    23365.722    -1407.224    -1407.224 
   43000   -8445.6644   -8445.6644    -8510.958    -8510.958    252.69307    252.69307    23336.949    23336.949      1000.49      1000.49 
Loop time of 267.982 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.322 ns/day, 74.439 hours/ns, 3.732 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    | 267.36     | 267.36     | 267.36     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10904    | 0.10904    | 0.10904    |   0.0 |  0.04
Output  | 0.00018646 | 0.00018646 | 0.00018646 |   0.0 |  0.00
Modify  | 0.44695    | 0.44695    | 0.44695    |   0.0 |  0.17
Other   |            | 0.06737    |            |       |  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:      131018.0 ave      131018 max      131018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131018
Ave neighs/atom = 65.509000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.3892664616, Press = -0.714026692748525
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   -8445.6644   -8445.6644    -8510.958    -8510.958    252.69307    252.69307    23336.949    23336.949      1000.49      1000.49 
   44000   -8449.5338   -8449.5338   -8514.8471   -8514.8471      252.769      252.769    23346.621    23346.621   -334.81664   -334.81664 
Loop time of 253.136 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.341 ns/day, 70.316 hours/ns, 3.950 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 252.56     | 252.56     | 252.56     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10254    | 0.10254    | 0.10254    |   0.0 |  0.04
Output  | 0.00015515 | 0.00015515 | 0.00015515 |   0.0 |  0.00
Modify  | 0.40516    | 0.40516    | 0.40516    |   0.0 |  0.16
Other   |            | 0.06423    |            |       |  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:      131354.0 ave      131354 max      131354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131354
Ave neighs/atom = 65.677000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.383354654162, Press = -0.25307597649687
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   -8449.5338   -8449.5338   -8514.8471   -8514.8471      252.769      252.769    23346.621    23346.621   -334.81664   -334.81664 
   45000   -8444.7007   -8444.7007   -8513.3189   -8513.3189     265.5594     265.5594    23349.078    23349.078   -172.40122   -172.40122 
Loop time of 249.828 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.346 ns/day, 69.397 hours/ns, 4.003 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.26     | 249.26     | 249.26     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10129    | 0.10129    | 0.10129    |   0.0 |  0.04
Output  | 0.00015694 | 0.00015694 | 0.00015694 |   0.0 |  0.00
Modify  | 0.40179    | 0.40179    | 0.40179    |   0.0 |  0.16
Other   |            | 0.06417    |            |       |  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:      131136.0 ave      131136 max      131136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131136
Ave neighs/atom = 65.568000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.403412731802, Press = -1.08449499918263
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   -8444.7007   -8444.7007   -8513.3189   -8513.3189     265.5594     265.5594    23349.078    23349.078   -172.40122   -172.40122 
   46000   -8448.3526   -8448.3526   -8514.1916   -8514.1916    254.80373    254.80373    23346.049    23346.049   -157.45061   -157.45061 
Loop time of 266.697 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.324 ns/day, 74.082 hours/ns, 3.750 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    | 266.09     | 266.09     | 266.09     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1067     | 0.1067     | 0.1067     |   0.0 |  0.04
Output  | 0.00019544 | 0.00019544 | 0.00019544 |   0.0 |  0.00
Modify  | 0.43556    | 0.43556    | 0.43556    |   0.0 |  0.16
Other   |            | 0.06645    |            |       |  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:      131214.0 ave      131214 max      131214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131214
Ave neighs/atom = 65.607000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.434722072487, Press = 0.448503983871313
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   -8448.3526   -8448.3526   -8514.1916   -8514.1916    254.80373    254.80373    23346.049    23346.049   -157.45061   -157.45061 
   47000   -8449.2833   -8449.2833   -8514.5635   -8514.5635    252.64094    252.64094    23369.883    23369.883    -1951.449    -1951.449 
Loop time of 247.427 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.349 ns/day, 68.730 hours/ns, 4.042 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    | 246.87     | 246.87     | 246.87     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10081    | 0.10081    | 0.10081    |   0.0 |  0.04
Output  | 0.00015195 | 0.00015195 | 0.00015195 |   0.0 |  0.00
Modify  | 0.39329    | 0.39329    | 0.39329    |   0.0 |  0.16
Other   |            | 0.0626     |            |       |  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:      131164.0 ave      131164 max      131164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131164
Ave neighs/atom = 65.582000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.454427034492, Press = -2.61091329627361
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   -8449.2833   -8449.2833   -8514.5635   -8514.5635    252.64094    252.64094    23369.883    23369.883    -1951.449    -1951.449 
   48000   -8446.7464   -8446.7464   -8514.2513   -8514.2513    261.25112    261.25112    23314.775    23314.775    2060.3684    2060.3684 
Loop time of 258.497 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.334 ns/day, 71.805 hours/ns, 3.869 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    | 257.91     | 257.91     | 257.91     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10457    | 0.10457    | 0.10457    |   0.0 |  0.04
Output  | 0.00015393 | 0.00015393 | 0.00015393 |   0.0 |  0.00
Modify  | 0.41878    | 0.41878    | 0.41878    |   0.0 |  0.16
Other   |            | 0.06407    |            |       |  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:      130964.0 ave      130964 max      130964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130964
Ave neighs/atom = 65.482000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.421025359008, Press = 0.528566367960527
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   -8446.7464   -8446.7464   -8514.2513   -8514.2513    261.25112    261.25112    23314.775    23314.775    2060.3684    2060.3684 
   49000   -8451.2434   -8451.2434   -8515.0814   -8515.0814    247.05974    247.05974    23367.311    23367.311   -1901.0911   -1901.0911 
Loop time of 257.065 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.336 ns/day, 71.407 hours/ns, 3.890 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.49     | 256.49     | 256.49     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1038     | 0.1038     | 0.1038     |   0.0 |  0.04
Output  | 0.00015577 | 0.00015577 | 0.00015577 |   0.0 |  0.00
Modify  | 0.4104     | 0.4104     | 0.4104     |   0.0 |  0.16
Other   |            | 0.06401    |            |       |  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:      131284.0 ave      131284 max      131284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131284
Ave neighs/atom = 65.642000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.369484595781, Press = -0.820298938438691
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   -8451.2434   -8451.2434   -8515.0814   -8515.0814    247.05974    247.05974    23367.311    23367.311   -1901.0911   -1901.0911 
   50000   -8449.0005   -8449.0005   -8515.3452   -8515.3452    256.76108    256.76108     23324.43     23324.43    1207.6314    1207.6314 
Loop time of 269.03 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.321 ns/day, 74.731 hours/ns, 3.717 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    | 268.41     | 268.41     | 268.41     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10832    | 0.10832    | 0.10832    |   0.0 |  0.04
Output  | 0.00019396 | 0.00019396 | 0.00019396 |   0.0 |  0.00
Modify  | 0.44486    | 0.44486    | 0.44486    |   0.0 |  0.17
Other   |            | 0.06709    |            |       |  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:      131018.0 ave      131018 max      131018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131018
Ave neighs/atom = 65.509000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.359737257023, Press = -0.765478446615787
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   -8449.0005   -8449.0005   -8515.3452   -8515.3452    256.76108    256.76108     23324.43     23324.43    1207.6314    1207.6314 
   51000    -8446.489    -8446.489    -8513.477    -8513.477    259.25038    259.25038    23361.674    23361.674   -1146.5463   -1146.5463 
Loop time of 259.559 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.333 ns/day, 72.100 hours/ns, 3.853 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    | 258.97     | 258.97     | 258.97     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10406    | 0.10406    | 0.10406    |   0.0 |  0.04
Output  | 0.00018826 | 0.00018826 | 0.00018826 |   0.0 |  0.00
Modify  | 0.41889    | 0.41889    | 0.41889    |   0.0 |  0.16
Other   |            | 0.06467    |            |       |  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:      131200.0 ave      131200 max      131200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131200
Ave neighs/atom = 65.600000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.354512981915, Press = 0.229000455349423
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    -8446.489    -8446.489    -8513.477    -8513.477    259.25038    259.25038    23361.674    23361.674   -1146.5463   -1146.5463 
   52000    -8449.818    -8449.818   -8514.7472   -8514.7472    251.28274    251.28274    23331.461    23331.461    716.57655    716.57655 
Loop time of 266.897 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.324 ns/day, 74.138 hours/ns, 3.747 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    | 266.28     | 266.28     | 266.28     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10838    | 0.10838    | 0.10838    |   0.0 |  0.04
Output  | 0.00021288 | 0.00021288 | 0.00021288 |   0.0 |  0.00
Modify  | 0.44281    | 0.44281    | 0.44281    |   0.0 |  0.17
Other   |            | 0.06714    |            |       |  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:      131064.0 ave      131064 max      131064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131064
Ave neighs/atom = 65.532000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.354015430383, Press = -1.78925189054428
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    -8449.818    -8449.818   -8514.7472   -8514.7472    251.28274    251.28274    23331.461    23331.461    716.57655    716.57655 
   53000   -8446.5519   -8446.5519   -8512.6146   -8512.6146    255.66948    255.66948     23344.32     23344.32    210.06472    210.06472 
Loop time of 248.576 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.348 ns/day, 69.049 hours/ns, 4.023 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.02     | 248.02     | 248.02     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10042    | 0.10042    | 0.10042    |   0.0 |  0.04
Output  | 0.00019493 | 0.00019493 | 0.00019493 |   0.0 |  0.00
Modify  | 0.39362    | 0.39362    | 0.39362    |   0.0 |  0.16
Other   |            | 0.0627     |            |       |  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:      131192.0 ave      131192 max      131192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131192
Ave neighs/atom = 65.596000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.332291597347, Press = 1.58893011413151
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   -8446.5519   -8446.5519   -8512.6146   -8512.6146    255.66948    255.66948     23344.32     23344.32    210.06472    210.06472 
   54000   -8451.6809   -8451.6809   -8514.4333   -8514.4333    242.85815    242.85815    23355.097    23355.097   -1041.0935   -1041.0935 
Loop time of 244.665 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.353 ns/day, 67.962 hours/ns, 4.087 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    | 244.12     | 244.12     | 244.12     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098531   | 0.098531   | 0.098531   |   0.0 |  0.04
Output  | 0.00015249 | 0.00015249 | 0.00015249 |   0.0 |  0.00
Modify  | 0.37984    | 0.37984    | 0.37984    |   0.0 |  0.16
Other   |            | 0.06157    |            |       |  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:      131292.0 ave      131292 max      131292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131292
Ave neighs/atom = 65.646000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.301112866623, Press = -1.53691750134496
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   -8451.6809   -8451.6809   -8514.4333   -8514.4333    242.85815    242.85815    23355.097    23355.097   -1041.0935   -1041.0935 
   55000   -8447.6527   -8447.6527   -8511.9196   -8511.9196    248.71975    248.71975    23327.334    23327.334    1435.4149    1435.4149 
Loop time of 259.654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.333 ns/day, 72.126 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.06     | 259.06     | 259.06     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10378    | 0.10378    | 0.10378    |   0.0 |  0.04
Output  | 0.00015492 | 0.00015492 | 0.00015492 |   0.0 |  0.00
Modify  | 0.42107    | 0.42107    | 0.42107    |   0.0 |  0.16
Other   |            | 0.0656     |            |       |  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:      131020.0 ave      131020 max      131020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0