# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.302343912422657*${_u_distance}
variable latticeconst_converted equal 3.302343912422657*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.30234391242266
Lattice spacing in x,y,z = 3.3023439 3.3023439 3.3023439
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 (33.023439 33.023439 33.023439)
  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 (33.023439 33.023439 33.023439)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Ta

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

kim interactions Ta
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_HuangLiuDuan_2021_HfNbTaTiZr__MO_893505888031_001
pair_coeff * * Ta
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 180.9479

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16107.817   -16107.817   -16183.565   -16183.565       293.15       293.15     36013.63     36013.63    2246.5748    2246.5748 
    1000   -16028.237   -16028.237   -16096.549   -16096.549    264.37618    264.37618    36067.619    36067.619    7310.7245    7310.7245 
Loop time of 542.604 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.159 ns/day, 150.723 hours/ns, 1.843 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    | 542.08     | 542.08     | 542.08     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10103    | 0.10103    | 0.10103    |   0.0 |  0.02
Output  | 0.00024275 | 0.00024275 | 0.00024275 |   0.0 |  0.00
Modify  | 0.36472    | 0.36472    | 0.36472    |   0.0 |  0.07
Other   |            | 0.05862    |            |       |  0.01

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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16028.237   -16028.237   -16096.549   -16096.549    264.37618    264.37618    36067.619    36067.619    7310.7245    7310.7245 
    2000    -16028.07    -16028.07   -16106.015   -16106.015    301.65212    301.65212    36206.144    36206.144   -1003.6887   -1003.6887 
Loop time of 566.44 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.153 ns/day, 157.344 hours/ns, 1.765 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    | 565.9      | 565.9      | 565.9      |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10132    | 0.10132    | 0.10132    |   0.0 |  0.02
Output  | 0.00023745 | 0.00023745 | 0.00023745 |   0.0 |  0.00
Modify  | 0.37524    | 0.37524    | 0.37524    |   0.0 |  0.07
Other   |            | 0.0613     |            |       |  0.01

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:      128858.0 ave      128858 max      128858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128858
Ave neighs/atom = 64.429000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -16028.07    -16028.07   -16106.015   -16106.015    301.65212    301.65212    36206.144    36206.144   -1003.6887   -1003.6887 
    3000   -16031.051   -16031.051   -16109.093   -16109.093    302.03143    302.03143    36165.491    36165.491     948.4605     948.4605 
Loop time of 597.634 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 166.010 hours/ns, 1.673 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    | 597.05     | 597.05     | 597.05     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10732    | 0.10732    | 0.10732    |   0.0 |  0.02
Output  | 0.00019212 | 0.00019212 | 0.00019212 |   0.0 |  0.00
Modify  | 0.41312    | 0.41312    | 0.41312    |   0.0 |  0.07
Other   |            | 0.06442    |            |       |  0.01

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:      128496.0 ave      128496 max      128496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128496
Ave neighs/atom = 64.248000
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16031.051   -16031.051   -16109.093   -16109.093    302.03143    302.03143    36165.491    36165.491     948.4605     948.4605 
    4000   -16031.503   -16031.503   -16103.545   -16103.545    278.81006    278.81006    36191.194    36191.194   -92.176912   -92.176912 
Loop time of 546.919 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.158 ns/day, 151.922 hours/ns, 1.828 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    | 546.41     | 546.41     | 546.41     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098078   | 0.098078   | 0.098078   |   0.0 |  0.02
Output  | 0.00019294 | 0.00019294 | 0.00019294 |   0.0 |  0.00
Modify  | 0.35263    | 0.35263    | 0.35263    |   0.0 |  0.06
Other   |            | 0.06003    |            |       |  0.01

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:      128470.0 ave      128470 max      128470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128470
Ave neighs/atom = 64.235000
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16031.503   -16031.503   -16103.545   -16103.545    278.81006    278.81006    36191.194    36191.194   -92.176912   -92.176912 
    5000    -16030.82    -16030.82   -16101.999   -16101.999    275.47007    275.47007    36216.277    36216.277    -1554.026    -1554.026 
Loop time of 571.395 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.151 ns/day, 158.721 hours/ns, 1.750 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    | 570.85     | 570.85     | 570.85     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10324    | 0.10324    | 0.10324    |   0.0 |  0.02
Output  | 0.00019543 | 0.00019543 | 0.00019543 |   0.0 |  0.00
Modify  | 0.38405    | 0.38405    | 0.38405    |   0.0 |  0.07
Other   |            | 0.06115    |            |       |  0.01

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:      128730.0 ave      128730 max      128730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128730
Ave neighs/atom = 64.365000
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 = 293.263693428631, Press = 101.915119904267
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -16030.82    -16030.82   -16101.999   -16101.999    275.47007    275.47007    36216.277    36216.277    -1554.026    -1554.026 
    6000   -16031.311   -16031.311   -16103.435   -16103.435    279.12579    279.12579    36193.087    36193.087   -265.56096   -265.56096 
Loop time of 559.079 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.155 ns/day, 155.300 hours/ns, 1.789 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 558.54     | 558.54     | 558.54     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10036    | 0.10036    | 0.10036    |   0.0 |  0.02
Output  | 0.00015976 | 0.00015976 | 0.00015976 |   0.0 |  0.00
Modify  | 0.38234    | 0.38234    | 0.38234    |   0.0 |  0.07
Other   |            | 0.05987    |            |       |  0.01

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:      128596.0 ave      128596 max      128596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128596
Ave neighs/atom = 64.298000
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 = 293.73578010171, Press = 1.52943264259925
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16031.311   -16031.311   -16103.435   -16103.435    279.12579    279.12579    36193.087    36193.087   -265.56096   -265.56096 
    7000     -16031.7     -16031.7   -16102.557   -16102.557    274.22147    274.22147    36202.844    36202.844   -540.42129   -540.42129 
Loop time of 594.827 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.230 hours/ns, 1.681 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    | 594.23     | 594.23     | 594.23     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10725    | 0.10725    | 0.10725    |   0.0 |  0.02
Output  | 0.00018149 | 0.00018149 | 0.00018149 |   0.0 |  0.00
Modify  | 0.42977    | 0.42977    | 0.42977    |   0.0 |  0.07
Other   |            | 0.06279    |            |       |  0.01

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:      128668.0 ave      128668 max      128668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128668
Ave neighs/atom = 64.334000
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 = 293.799920589653, Press = 26.1375247263203
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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     -16031.7     -16031.7   -16102.557   -16102.557    274.22147    274.22147    36202.844    36202.844   -540.42129   -540.42129 
    8000   -16028.011   -16028.011   -16107.954   -16107.954    309.38511    309.38511    36255.742    36255.742   -3718.2254   -3718.2254 
Loop time of 575.802 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.150 ns/day, 159.945 hours/ns, 1.737 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    | 575.24     | 575.24     | 575.24     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10174    | 0.10174    | 0.10174    |   0.0 |  0.02
Output  | 0.00020293 | 0.00020293 | 0.00020293 |   0.0 |  0.00
Modify  | 0.40284    | 0.40284    | 0.40284    |   0.0 |  0.07
Other   |            | 0.06187    |            |       |  0.01

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:      128534.0 ave      128534 max      128534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128534
Ave neighs/atom = 64.267000
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 = 293.910293147718, Press = -1.42362545730674
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16028.011   -16028.011   -16107.954   -16107.954    309.38511    309.38511    36255.742    36255.742   -3718.2254   -3718.2254 
    9000   -16031.154   -16031.154   -16107.569   -16107.569    295.73382    295.73382    36240.096    36240.096   -2815.8685   -2815.8685 
Loop time of 597.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.898 hours/ns, 1.674 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    | 596.63     | 596.63     | 596.63     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10691    | 0.10691    | 0.10691    |   0.0 |  0.02
Output  | 0.0001553  | 0.0001553  | 0.0001553  |   0.0 |  0.00
Modify  | 0.4311     | 0.4311     | 0.4311     |   0.0 |  0.07
Other   |            | 0.06301    |            |       |  0.01

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:      128392.0 ave      128392 max      128392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128392
Ave neighs/atom = 64.196000
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 = 293.309560100533, Press = 9.321900083617
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16031.154   -16031.154   -16107.569   -16107.569    295.73382    295.73382    36240.096    36240.096   -2815.8685   -2815.8685 
   10000   -16028.278   -16028.278   -16108.554   -16108.554    310.67565    310.67565    36237.752    36237.752   -2641.2284   -2641.2284 
Loop time of 594.558 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.155 hours/ns, 1.682 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    | 593.96     | 593.96     | 593.96     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10639    | 0.10639    | 0.10639    |   0.0 |  0.02
Output  | 0.00015667 | 0.00015667 | 0.00015667 |   0.0 |  0.00
Modify  | 0.4317     | 0.4317     | 0.4317     |   0.0 |  0.07
Other   |            | 0.06302    |            |       |  0.01

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:      128448.0 ave      128448 max      128448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128448
Ave neighs/atom = 64.224000
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 = 293.339411970284, Press = 1.38057330882386
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16028.278   -16028.278   -16108.554   -16108.554    310.67565    310.67565    36237.752    36237.752   -2641.2284   -2641.2284 
   11000   -16031.027   -16031.027   -16104.388   -16104.388    283.91461    283.91461    36177.632    36177.632    689.14114    689.14114 
Loop time of 585.987 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 162.774 hours/ns, 1.707 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    | 585.4      | 585.4      | 585.4      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10472    | 0.10472    | 0.10472    |   0.0 |  0.02
Output  | 0.00015417 | 0.00015417 | 0.00015417 |   0.0 |  0.00
Modify  | 0.42097    | 0.42097    | 0.42097    |   0.0 |  0.07
Other   |            | 0.06226    |            |       |  0.01

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:      128398.0 ave      128398 max      128398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128398
Ave neighs/atom = 64.199000
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 = 293.531318585672, Press = 5.21049709892506
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16031.027   -16031.027   -16104.388   -16104.388    283.91461    283.91461    36177.632    36177.632    689.14114    689.14114 
   12000   -16032.516   -16032.516   -16103.889   -16103.889    276.22029    276.22029    36222.338    36222.338   -1834.6279   -1834.6279 
Loop time of 594.821 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.228 hours/ns, 1.681 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    | 594.22     | 594.22     | 594.22     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10648    | 0.10648    | 0.10648    |   0.0 |  0.02
Output  | 0.00016025 | 0.00016025 | 0.00016025 |   0.0 |  0.00
Modify  | 0.42775    | 0.42775    | 0.42775    |   0.0 |  0.07
Other   |            | 0.06288    |            |       |  0.01

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:      128558.0 ave      128558 max      128558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128558
Ave neighs/atom = 64.279000
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 = 293.220821997031, Press = 11.2922321442938
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16032.516   -16032.516   -16103.889   -16103.889    276.22029    276.22029    36222.338    36222.338   -1834.6279   -1834.6279 
   13000   -16028.925   -16028.925   -16103.021   -16103.021    286.76029    286.76029    36227.967    36227.967   -1784.4668   -1784.4668 
Loop time of 607.012 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.142 ns/day, 168.614 hours/ns, 1.647 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 606.4      | 606.4      | 606.4      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10704    | 0.10704    | 0.10704    |   0.0 |  0.02
Output  | 0.00015781 | 0.00015781 | 0.00015781 |   0.0 |  0.00
Modify  | 0.44404    | 0.44404    | 0.44404    |   0.0 |  0.07
Other   |            | 0.06405    |            |       |  0.01

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:      128584.0 ave      128584 max      128584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128584
Ave neighs/atom = 64.292000
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 = 293.04887945381, Press = 6.760679502826
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16028.925   -16028.925   -16103.021   -16103.021    286.76029    286.76029    36227.967    36227.967   -1784.4668   -1784.4668 
   14000   -16035.003   -16035.003   -16105.721   -16105.721    273.68565    273.68565    36219.235    36219.235   -1771.8764   -1771.8764 
Loop time of 573.291 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.151 ns/day, 159.248 hours/ns, 1.744 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    | 572.72     | 572.72     | 572.72     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10303    | 0.10303    | 0.10303    |   0.0 |  0.02
Output  | 0.00021751 | 0.00021751 | 0.00021751 |   0.0 |  0.00
Modify  | 0.40431    | 0.40431    | 0.40431    |   0.0 |  0.07
Other   |            | 0.0622     |            |       |  0.01

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:      128576.0 ave      128576 max      128576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128576
Ave neighs/atom = 64.288000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.846437399795, Press = 5.07597824071742
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16035.003   -16035.003   -16105.721   -16105.721    273.68565    273.68565    36219.235    36219.235   -1771.8764   -1771.8764 
   15000   -16028.657   -16028.657   -16104.515   -16104.515    293.57977    293.57977    36190.197    36190.197    132.61807    132.61807 
Loop time of 601.384 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 167.051 hours/ns, 1.663 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    | 600.77     | 600.77     | 600.77     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10742    | 0.10742    | 0.10742    |   0.0 |  0.02
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.43747    | 0.43747    | 0.43747    |   0.0 |  0.07
Other   |            | 0.06589    |            |       |  0.01

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:      128504.0 ave      128504 max      128504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128504
Ave neighs/atom = 64.252000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.772744245978, Press = 10.0177560942177
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16028.657   -16028.657   -16104.515   -16104.515    293.57977    293.57977    36190.197    36190.197    132.61807    132.61807 
   16000   -16032.705   -16032.705   -16109.624   -16109.624    297.68209    297.68209    36177.127    36177.127    296.49976    296.49976 
Loop time of 580.758 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.149 ns/day, 161.322 hours/ns, 1.722 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    | 580.19     | 580.19     | 580.19     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10232    | 0.10232    | 0.10232    |   0.0 |  0.02
Output  | 0.00020224 | 0.00020224 | 0.00020224 |   0.0 |  0.00
Modify  | 0.40678    | 0.40678    | 0.40678    |   0.0 |  0.07
Other   |            | 0.06216    |            |       |  0.01

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:      128546.0 ave      128546 max      128546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128546
Ave neighs/atom = 64.273000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.780794189319, Press = 5.08472964978663
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16032.705   -16032.705   -16109.624   -16109.624    297.68209    297.68209    36177.127    36177.127    296.49976    296.49976 
   17000   -16029.647   -16029.647   -16106.805   -16106.805    298.60955    298.60955     36222.56     36222.56   -1784.0018   -1784.0018 
Loop time of 603.106 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.529 hours/ns, 1.658 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    | 602.5      | 602.5      | 602.5      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10755    | 0.10755    | 0.10755    |   0.0 |  0.02
Output  | 0.00015554 | 0.00015554 | 0.00015554 |   0.0 |  0.00
Modify  | 0.43679    | 0.43679    | 0.43679    |   0.0 |  0.07
Other   |            | 0.06389    |            |       |  0.01

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:      128504.0 ave      128504 max      128504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128504
Ave neighs/atom = 64.252000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.682752459071, Press = 2.13249559871213
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16029.647   -16029.647   -16106.805   -16106.805    298.60955    298.60955     36222.56     36222.56   -1784.0018   -1784.0018 
   18000   -16030.433   -16030.433   -16105.179   -16105.179     289.2753     289.2753    36213.966    36213.966   -1253.5705   -1253.5705 
Loop time of 607.957 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.142 ns/day, 168.877 hours/ns, 1.645 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    | 607.34     | 607.34     | 607.34     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10641    | 0.10641    | 0.10641    |   0.0 |  0.02
Output  | 0.00019038 | 0.00019038 | 0.00019038 |   0.0 |  0.00
Modify  | 0.44471    | 0.44471    | 0.44471    |   0.0 |  0.07
Other   |            | 0.064      |            |       |  0.01

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:      128450.0 ave      128450 max      128450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128450
Ave neighs/atom = 64.225000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.671948664832, Press = 2.93460047094094
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16030.433   -16030.433   -16105.179   -16105.179     289.2753     289.2753    36213.966    36213.966   -1253.5705   -1253.5705 
   19000   -16031.572   -16031.572   -16105.387   -16105.387    285.67163    285.67163    36184.159    36184.159    169.46208    169.46208 
Loop time of 605.985 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 168.329 hours/ns, 1.650 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 605.37     | 605.37     | 605.37     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10615    | 0.10615    | 0.10615    |   0.0 |  0.02
Output  | 0.00015158 | 0.00015158 | 0.00015158 |   0.0 |  0.00
Modify  | 0.44073    | 0.44073    | 0.44073    |   0.0 |  0.07
Other   |            | 0.06492    |            |       |  0.01

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:      128568.0 ave      128568 max      128568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128568
Ave neighs/atom = 64.284000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.618697529956, Press = 4.32690241652718
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16031.572   -16031.572   -16105.387   -16105.387    285.67163    285.67163    36184.159    36184.159    169.46208    169.46208 
   20000   -16029.112   -16029.112    -16106.33    -16106.33    298.84198    298.84198    36188.674    36188.674   -57.703256   -57.703256 
Loop time of 594.056 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.016 hours/ns, 1.683 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    | 593.45     | 593.45     | 593.45     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10657    | 0.10657    | 0.10657    |   0.0 |  0.02
Output  | 0.00015785 | 0.00015785 | 0.00015785 |   0.0 |  0.00
Modify  | 0.43045    | 0.43045    | 0.43045    |   0.0 |  0.07
Other   |            | 0.06535    |            |       |  0.01

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:      128538.0 ave      128538 max      128538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128538
Ave neighs/atom = 64.269000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.633765975054, Press = 2.40196876437796
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16029.112   -16029.112    -16106.33    -16106.33    298.84198    298.84198    36188.674    36188.674   -57.703256   -57.703256 
   21000   -16032.674   -16032.674   -16103.728   -16103.728    274.98669    274.98669    36174.194    36174.194    699.26128    699.26128 
Loop time of 582.223 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.148 ns/day, 161.729 hours/ns, 1.718 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    | 581.64     | 581.64     | 581.64     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10356    | 0.10356    | 0.10356    |   0.0 |  0.02
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.41554    | 0.41554    | 0.41554    |   0.0 |  0.07
Other   |            | 0.06342    |            |       |  0.01

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:      128576.0 ave      128576 max      128576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128576
Ave neighs/atom = 64.288000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.836009997422, Press = 4.34016929169535
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16032.674   -16032.674   -16103.728   -16103.728    274.98669    274.98669    36174.194    36174.194    699.26128    699.26128 
   22000   -16031.907   -16031.907   -16106.683   -16106.683    289.39131    289.39131    36151.471    36151.471    1805.1431    1805.1431 
Loop time of 590.489 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 164.025 hours/ns, 1.694 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    | 589.9      | 589.9      | 589.9      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10475    | 0.10475    | 0.10475    |   0.0 |  0.02
Output  | 0.00015508 | 0.00015508 | 0.00015508 |   0.0 |  0.00
Modify  | 0.41872    | 0.41872    | 0.41872    |   0.0 |  0.07
Other   |            | 0.06446    |            |       |  0.01

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:      128704.0 ave      128704 max      128704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128704
Ave neighs/atom = 64.352000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.967914189212, Press = 4.22248960949526
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16031.907   -16031.907   -16106.683   -16106.683    289.39131    289.39131    36151.471    36151.471    1805.1431    1805.1431 
   23000    -16028.54    -16028.54   -16104.264   -16104.264    293.06051    293.06051    36169.115    36169.115    1075.1572    1075.1572 
Loop time of 551.611 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.157 ns/day, 153.225 hours/ns, 1.813 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    | 551.08     | 551.08     | 551.08     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098888   | 0.098888   | 0.098888   |   0.0 |  0.02
Output  | 0.00021304 | 0.00021304 | 0.00021304 |   0.0 |  0.00
Modify  | 0.37309    | 0.37309    | 0.37309    |   0.0 |  0.07
Other   |            | 0.06017    |            |       |  0.01

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:      128540.0 ave      128540 max      128540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128540
Ave neighs/atom = 64.270000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.973203564473, Press = 5.64866560641222
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -16028.54    -16028.54   -16104.264   -16104.264    293.06051    293.06051    36169.115    36169.115    1075.1572    1075.1572 
   24000   -16029.957   -16029.957   -16108.105   -16108.105     302.4399     302.4399    36151.662    36151.662    1760.3193    1760.3193 
Loop time of 601.258 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 167.016 hours/ns, 1.663 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    | 600.65     | 600.65     | 600.65     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1074     | 0.1074     | 0.1074     |   0.0 |  0.02
Output  | 0.00015624 | 0.00015624 | 0.00015624 |   0.0 |  0.00
Modify  | 0.43902    | 0.43902    | 0.43902    |   0.0 |  0.07
Other   |            | 0.06553    |            |       |  0.01

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:      128574.0 ave      128574 max      128574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128574
Ave neighs/atom = 64.287000
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 = 293.149334773273, Press = 5.45159798187163
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16029.957   -16029.957   -16108.105   -16108.105     302.4399     302.4399    36151.662    36151.662    1760.3193    1760.3193 
   25000   -16029.432   -16029.432   -16108.364   -16108.364    305.47315    305.47315    36210.843    36210.843   -1287.8874   -1287.8874 
Loop time of 584.631 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.148 ns/day, 162.398 hours/ns, 1.710 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    | 584.04     | 584.04     | 584.04     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10529    | 0.10529    | 0.10529    |   0.0 |  0.02
Output  | 0.00021247 | 0.00021247 | 0.00021247 |   0.0 |  0.00
Modify  | 0.42073    | 0.42073    | 0.42073    |   0.0 |  0.07
Other   |            | 0.06383    |            |       |  0.01

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:      128592.0 ave      128592 max      128592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128592
Ave neighs/atom = 64.296000
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 = 293.144244128863, Press = 3.01379197659068
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16029.432   -16029.432   -16108.364   -16108.364    305.47315    305.47315    36210.843    36210.843   -1287.8874   -1287.8874 
   26000   -16031.836   -16031.836   -16110.253   -16110.253    303.48498    303.48498    36167.428    36167.428    751.31475    751.31475 
Loop time of 602.815 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.449 hours/ns, 1.659 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 602.2      | 602.2      | 602.2      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10908    | 0.10908    | 0.10908    |   0.0 |  0.02
Output  | 0.00020144 | 0.00020144 | 0.00020144 |   0.0 |  0.00
Modify  | 0.44081    | 0.44081    | 0.44081    |   0.0 |  0.07
Other   |            | 0.06589    |            |       |  0.01

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:      128492.0 ave      128492 max      128492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128492
Ave neighs/atom = 64.246000
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 = 293.214119195039, Press = 1.02901884699419
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16031.836   -16031.836   -16110.253   -16110.253    303.48498    303.48498    36167.428    36167.428    751.31475    751.31475 
   27000   -16032.707   -16032.707   -16103.658   -16103.658    274.59031    274.59031    36171.418    36171.418     824.2331     824.2331 
Loop time of 603.75 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.708 hours/ns, 1.656 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    | 603.13     | 603.13     | 603.13     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10991    | 0.10991    | 0.10991    |   0.0 |  0.02
Output  | 0.00015424 | 0.00015424 | 0.00015424 |   0.0 |  0.00
Modify  | 0.44216    | 0.44216    | 0.44216    |   0.0 |  0.07
Other   |            | 0.06639    |            |       |  0.01

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:      128446.0 ave      128446 max      128446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128446
Ave neighs/atom = 64.223000
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 = 293.139804203412, Press = 1.6899323807874
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16032.707   -16032.707   -16103.658   -16103.658    274.59031    274.59031    36171.418    36171.418     824.2331     824.2331 
   28000    -16030.47    -16030.47     -16107.6     -16107.6    298.49816    298.49816    36115.145    36115.145     3748.561     3748.561 
Loop time of 593.787 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 164.941 hours/ns, 1.684 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    | 593.19     | 593.19     | 593.19     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10759    | 0.10759    | 0.10759    |   0.0 |  0.02
Output  | 0.00019094 | 0.00019094 | 0.00019094 |   0.0 |  0.00
Modify  | 0.42812    | 0.42812    | 0.42812    |   0.0 |  0.07
Other   |            | 0.06533    |            |       |  0.01

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:      128532.0 ave      128532 max      128532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128532
Ave neighs/atom = 64.266000
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 = 293.16070168207, Press = 0.450909742930747
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -16030.47    -16030.47     -16107.6     -16107.6    298.49816    298.49816    36115.145    36115.145     3748.561     3748.561 
   29000   -16032.036   -16032.036   -16107.837   -16107.837    293.35747    293.35747    36147.527    36147.527    1942.8009    1942.8009 
Loop time of 551.779 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.157 ns/day, 153.272 hours/ns, 1.812 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    | 551.25     | 551.25     | 551.25     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097755   | 0.097755   | 0.097755   |   0.0 |  0.02
Output  | 0.00015616 | 0.00015616 | 0.00015616 |   0.0 |  0.00
Modify  | 0.37321    | 0.37321    | 0.37321    |   0.0 |  0.07
Other   |            | 0.06034    |            |       |  0.01

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:      128584.0 ave      128584 max      128584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128584
Ave neighs/atom = 64.292000
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 = 293.126337378912, Press = 1.56885215402729
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16032.036   -16032.036   -16107.837   -16107.837    293.35747    293.35747    36147.527    36147.527    1942.8009    1942.8009 
   30000   -16027.415   -16027.415   -16106.102   -16106.102    304.52367    304.52367    36170.035    36170.035    1021.1544    1021.1544 
Loop time of 548.019 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.158 ns/day, 152.227 hours/ns, 1.825 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    | 547.5      | 547.5      | 547.5      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096696   | 0.096696   | 0.096696   |   0.0 |  0.02
Output  | 0.00019083 | 0.00019083 | 0.00019083 |   0.0 |  0.00
Modify  | 0.36583    | 0.36583    | 0.36583    |   0.0 |  0.07
Other   |            | 0.05986    |            |       |  0.01

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:      128498.0 ave      128498 max      128498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128498
Ave neighs/atom = 64.249000
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 = 293.129033754806, Press = 2.1922425256698
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16027.415   -16027.415   -16106.102   -16106.102    304.52367    304.52367    36170.035    36170.035    1021.1544    1021.1544 
   31000   -16027.422   -16027.422   -16105.062   -16105.062    300.47373    300.47373    36170.954    36170.954    996.00933    996.00933 
Loop time of 571.566 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.151 ns/day, 158.768 hours/ns, 1.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    | 571.01     | 571.01     | 571.01     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1018     | 0.1018     | 0.1018     |   0.0 |  0.02
Output  | 0.00015576 | 0.00015576 | 0.00015576 |   0.0 |  0.00
Modify  | 0.39601    | 0.39601    | 0.39601    |   0.0 |  0.07
Other   |            | 0.06212    |            |       |  0.01

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:      128532.0 ave      128532 max      128532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128532
Ave neighs/atom = 64.266000
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 = 293.120938747362, Press = 0.779703909064265
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16027.422   -16027.422   -16105.062   -16105.062    300.47373    300.47373    36170.954    36170.954    996.00933    996.00933 
   32000   -16029.846   -16029.846   -16108.212   -16108.212      303.283      303.283    36166.406    36166.406    1068.1866    1068.1866 
Loop time of 576.304 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.150 ns/day, 160.085 hours/ns, 1.735 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    | 575.74     | 575.74     | 575.74     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10087    | 0.10087    | 0.10087    |   0.0 |  0.02
Output  | 0.00019307 | 0.00019307 | 0.00019307 |   0.0 |  0.00
Modify  | 0.40031    | 0.40031    | 0.40031    |   0.0 |  0.07
Other   |            | 0.06234    |            |       |  0.01

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:      128548.0 ave      128548 max      128548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128548
Ave neighs/atom = 64.274000
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 = 293.175027407988, Press = -0.299332801466656
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -16029.846   -16029.846   -16108.212   -16108.212      303.283      303.283    36166.406    36166.406    1068.1866    1068.1866 
   33000   -16030.609   -16030.609   -16105.286   -16105.286    289.00625    289.00625    36183.575    36183.575    303.51721    303.51721 
Loop time of 599.82 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.617 hours/ns, 1.667 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    | 599.22     | 599.22     | 599.22     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10546    | 0.10546    | 0.10546    |   0.0 |  0.02
Output  | 0.00015386 | 0.00015386 | 0.00015386 |   0.0 |  0.00
Modify  | 0.42954    | 0.42954    | 0.42954    |   0.0 |  0.07
Other   |            | 0.0643     |            |       |  0.01

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:      128466.0 ave      128466 max      128466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0