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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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   -16112.985   -16112.985   -16183.565   -16183.565       273.15       273.15     36013.63     36013.63    2093.3039    2093.3039 
    1000   -16039.047   -16039.047   -16103.356   -16103.356    248.88205    248.88205    36111.349    36111.349    4172.7951    4172.7951 
Loop time of 546.222 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.158 ns/day, 151.728 hours/ns, 1.831 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    | 545.69     | 545.69     | 545.69     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10076    | 0.10076    | 0.10076    |   0.0 |  0.02
Output  | 0.00019721 | 0.00019721 | 0.00019721 |   0.0 |  0.00
Modify  | 0.36995    | 0.36995    | 0.36995    |   0.0 |  0.07
Other   |            | 0.0621     |            |       |  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   -16039.047   -16039.047   -16103.356   -16103.356    248.88205    248.88205    36111.349    36111.349    4172.7951    4172.7951 
    2000   -16038.989   -16038.989   -16110.604   -16110.604    277.15818    277.15818    36192.017    36192.017   -832.82069   -832.82069 
Loop time of 549.795 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.157 ns/day, 152.721 hours/ns, 1.819 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    | 549.28     | 549.28     | 549.28     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098682   | 0.098682   | 0.098682   |   0.0 |  0.02
Output  | 0.00019486 | 0.00019486 | 0.00019486 |   0.0 |  0.00
Modify  | 0.35904    | 0.35904    | 0.35904    |   0.0 |  0.07
Other   |            | 0.06142    |            |       |  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:      128632.0 ave      128632 max      128632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128632
Ave neighs/atom = 64.316000
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   -16038.989   -16038.989   -16110.604   -16110.604    277.15818    277.15818    36192.017    36192.017   -832.82069   -832.82069 
    3000   -16041.262   -16041.262   -16114.252   -16114.252    282.47676    282.47676    36155.185    36155.185     877.0562     877.0562 
Loop time of 575.614 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.150 ns/day, 159.893 hours/ns, 1.737 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.06     | 575.06     | 575.06     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10426    | 0.10426    | 0.10426    |   0.0 |  0.02
Output  | 0.00019527 | 0.00019527 | 0.00019527 |   0.0 |  0.00
Modify  | 0.3895     | 0.3895     | 0.3895     |   0.0 |  0.07
Other   |            | 0.06313    |            |       |  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 = 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   -16041.262   -16041.262   -16114.252   -16114.252    282.47676    282.47676    36155.185    36155.185     877.0562     877.0562 
    4000   -16041.672   -16041.672   -16108.993   -16108.993    260.53645    260.53645     36237.59     36237.59   -3201.4791   -3201.4791 
Loop time of 602.938 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.483 hours/ns, 1.659 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    | 602.34     | 602.34     | 602.34     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10904    | 0.10904    | 0.10904    |   0.0 |  0.02
Output  | 0.00019637 | 0.00019637 | 0.00019637 |   0.0 |  0.00
Modify  | 0.41945    | 0.41945    | 0.41945    |   0.0 |  0.07
Other   |            | 0.06679    |            |       |  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:      128384.0 ave      128384 max      128384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128384
Ave neighs/atom = 64.192000
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   -16041.672   -16041.672   -16108.993   -16108.993    260.53645    260.53645     36237.59     36237.59   -3201.4791   -3201.4791 
    5000   -16041.295   -16041.295   -16108.193   -16108.193    258.90299    258.90299    36172.809    36172.809    80.552171    80.552171 
Loop time of 587.656 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.238 hours/ns, 1.702 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    | 587.08     | 587.08     | 587.08     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10549    | 0.10549    | 0.10549    |   0.0 |  0.02
Output  | 0.00018619 | 0.00018619 | 0.00018619 |   0.0 |  0.00
Modify  | 0.40769    | 0.40769    | 0.40769    |   0.0 |  0.07
Other   |            | 0.06456    |            |       |  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 = 268.644261352592, Press = -345.184322103041
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   -16041.295   -16041.295   -16108.193   -16108.193    258.90299    258.90299    36172.809    36172.809    80.552171    80.552171 
    6000    -16041.76    -16041.76   -16109.238   -16109.238    261.14624    261.14624    36149.971    36149.971    1266.0818    1266.0818 
Loop time of 605.355 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 168.154 hours/ns, 1.652 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    | 604.73     | 604.73     | 604.73     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10812    | 0.10812    | 0.10812    |   0.0 |  0.02
Output  | 0.00015625 | 0.00015625 | 0.00015625 |   0.0 |  0.00
Modify  | 0.44667    | 0.44667    | 0.44667    |   0.0 |  0.07
Other   |            | 0.06532    |            |       |  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 = 273.308178635654, Press = 13.7942044746368
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    -16041.76    -16041.76   -16109.238   -16109.238    261.14624    261.14624    36149.971    36149.971    1266.0818    1266.0818 
    7000    -16041.91    -16041.91   -16108.275   -16108.275    256.83997    256.83997    36203.477    36203.477   -1234.0731   -1234.0731 
Loop time of 597.095 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.860 hours/ns, 1.675 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.49     | 596.49     | 596.49     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10832    | 0.10832    | 0.10832    |   0.0 |  0.02
Output  | 0.00018761 | 0.00018761 | 0.00018761 |   0.0 |  0.00
Modify  | 0.43479    | 0.43479    | 0.43479    |   0.0 |  0.07
Other   |            | 0.0654     |            |       |  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:      128590.0 ave      128590 max      128590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128590
Ave neighs/atom = 64.295000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.298193275066, Press = 25.2798713033504
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    -16041.91    -16041.91   -16108.275   -16108.275    256.83997    256.83997    36203.477    36203.477   -1234.0731   -1234.0731 
    8000   -16039.714   -16039.714   -16113.475   -16113.475    285.46326    285.46326    36174.792    36174.792   -134.88868   -134.88868 
Loop time of 571.76 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.151 ns/day, 158.822 hours/ns, 1.749 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.19     | 571.19     | 571.19     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10266    | 0.10266    | 0.10266    |   0.0 |  0.02
Output  | 0.00019004 | 0.00019004 | 0.00019004 |   0.0 |  0.00
Modify  | 0.40106    | 0.40106    | 0.40106    |   0.0 |  0.07
Other   |            | 0.06361    |            |       |  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:      128434.0 ave      128434 max      128434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128434
Ave neighs/atom = 64.217000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.498989063405, Press = -17.5615949542113
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   -16039.714   -16039.714   -16113.475   -16113.475    285.46326    285.46326    36174.792    36174.792   -134.88868   -134.88868 
    9000   -16040.777   -16040.777   -16115.849   -16115.849    290.53752    290.53752    36176.163    36176.163    -278.8208    -278.8208 
Loop time of 557.129 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.155 ns/day, 154.758 hours/ns, 1.795 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    | 556.58     | 556.58     | 556.58     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1007     | 0.1007     | 0.1007     |   0.0 |  0.02
Output  | 0.00015723 | 0.00015723 | 0.00015723 |   0.0 |  0.00
Modify  | 0.38782    | 0.38782    | 0.38782    |   0.0 |  0.07
Other   |            | 0.06108    |            |       |  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:      128386.0 ave      128386 max      128386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128386
Ave neighs/atom = 64.193000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.506286779505, Press = -3.94855654606898
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   -16040.777   -16040.777   -16115.849   -16115.849    290.53752    290.53752    36176.163    36176.163    -278.8208    -278.8208 
   10000   -16044.163   -16044.163   -16116.927   -16116.927    281.60702    281.60702    36152.008    36152.008    894.84527    894.84527 
Loop time of 530.529 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.163 ns/day, 147.369 hours/ns, 1.885 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    | 530.02     | 530.02     | 530.02     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095119   | 0.095119   | 0.095119   |   0.0 |  0.02
Output  | 0.00015708 | 0.00015708 | 0.00015708 |   0.0 |  0.00
Modify  | 0.35094    | 0.35094    | 0.35094    |   0.0 |  0.07
Other   |            | 0.05848    |            |       |  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:      128362.0 ave      128362 max      128362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128362
Ave neighs/atom = 64.181000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.532931382745, Press = -3.14936073634948
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   -16044.163   -16044.163   -16116.927   -16116.927    281.60702    281.60702    36152.008    36152.008    894.84527    894.84527 
   11000   -16042.576   -16042.576   -16109.394   -16109.394    258.59103    258.59103    36144.724    36144.724    1654.9936    1654.9936 
Loop time of 553.493 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.156 ns/day, 153.748 hours/ns, 1.807 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    | 552.95     | 552.95     | 552.95     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10009    | 0.10009    | 0.10009    |   0.0 |  0.02
Output  | 0.000157   | 0.000157   | 0.000157   |   0.0 |  0.00
Modify  | 0.37996    | 0.37996    | 0.37996    |   0.0 |  0.07
Other   |            | 0.06052    |            |       |  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:      128382.0 ave      128382 max      128382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128382
Ave neighs/atom = 64.191000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.039914822662, Press = 8.77898074134372
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   -16042.576   -16042.576   -16109.394   -16109.394    258.59103    258.59103    36144.724    36144.724    1654.9936    1654.9936 
   12000   -16041.243   -16041.243   -16109.465   -16109.465      264.023      264.023    36217.354    36217.354   -2107.2535   -2107.2535 
Loop time of 606.017 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 168.338 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.4      | 605.4      | 605.4      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10727    | 0.10727    | 0.10727    |   0.0 |  0.02
Output  | 0.00020121 | 0.00020121 | 0.00020121 |   0.0 |  0.00
Modify  | 0.44312    | 0.44312    | 0.44312    |   0.0 |  0.07
Other   |            | 0.06509    |            |       |  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:      128536.0 ave      128536 max      128536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128536
Ave neighs/atom = 64.268000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.797111412634, Press = 1.47300615925014
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   -16041.243   -16041.243   -16109.465   -16109.465      264.023      264.023    36217.354    36217.354   -2107.2535   -2107.2535 
   13000   -16042.531   -16042.531   -16110.277   -16110.277    262.18281    262.18281    36184.516    36184.516   -434.43754   -434.43754 
Loop time of 593.344 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 164.818 hours/ns, 1.685 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    | 592.74     | 592.74     | 592.74     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10585    | 0.10585    | 0.10585    |   0.0 |  0.02
Output  | 0.00015699 | 0.00015699 | 0.00015699 |   0.0 |  0.00
Modify  | 0.43084    | 0.43084    | 0.43084    |   0.0 |  0.07
Other   |            | 0.0652     |            |       |  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:      128436.0 ave      128436 max      128436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128436
Ave neighs/atom = 64.218000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.935841865391, Press = -0.31584401284975
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   -16042.531   -16042.531   -16110.277   -16110.277    262.18281    262.18281    36184.516    36184.516   -434.43754   -434.43754 
   14000    -16038.79    -16038.79    -16107.46    -16107.46    265.76113    265.76113    36165.006    36165.006     850.2874     850.2874 
Loop time of 558.553 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.155 ns/day, 155.154 hours/ns, 1.790 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    | 558.01     | 558.01     | 558.01     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099145   | 0.099145   | 0.099145   |   0.0 |  0.02
Output  | 0.00020728 | 0.00020728 | 0.00020728 |   0.0 |  0.00
Modify  | 0.38309    | 0.38309    | 0.38309    |   0.0 |  0.07
Other   |            | 0.06171    |            |       |  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:      128522.0 ave      128522 max      128522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128522
Ave neighs/atom = 64.261000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.192927815045, Press = 0.798707063281847
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    -16038.79    -16038.79    -16107.46    -16107.46    265.76113    265.76113    36165.006    36165.006     850.2874     850.2874 
   15000   -16043.621   -16043.621   -16110.405   -16110.405    258.46068    258.46068    36220.501    36220.501   -2286.2017   -2286.2017 
Loop time of 589.347 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.707 hours/ns, 1.697 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    | 588.76     | 588.76     | 588.76     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10373    | 0.10373    | 0.10373    |   0.0 |  0.02
Output  | 0.0001972  | 0.0001972  | 0.0001972  |   0.0 |  0.00
Modify  | 0.4223     | 0.4223     | 0.4223     |   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:      128500.0 ave      128500 max      128500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128500
Ave neighs/atom = 64.250000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.10702852379, Press = 3.11869583451878
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   -16043.621   -16043.621   -16110.405   -16110.405    258.46068    258.46068    36220.501    36220.501   -2286.2017   -2286.2017 
   16000   -16035.438   -16035.438   -16111.742   -16111.742    295.30513    295.30513    36176.765    36176.765    93.800862    93.800862 
Loop time of 585.245 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.148 ns/day, 162.568 hours/ns, 1.709 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    | 584.66     | 584.66     | 584.66     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1024     | 0.1024     | 0.1024     |   0.0 |  0.02
Output  | 0.00015294 | 0.00015294 | 0.00015294 |   0.0 |  0.00
Modify  | 0.41971    | 0.41971    | 0.41971    |   0.0 |  0.07
Other   |            | 0.06426    |            |       |  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:      128404.0 ave      128404 max      128404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128404
Ave neighs/atom = 64.202000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.174052137421, Press = -1.1412008509889
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   -16035.438   -16035.438   -16111.742   -16111.742    295.30513    295.30513    36176.765    36176.765    93.800862    93.800862 
   17000   -16040.759   -16040.759   -16113.426   -16113.426    281.22985    281.22985    36119.165    36119.165    2959.1008    2959.1008 
Loop time of 604.777 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.994 hours/ns, 1.654 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    | 604.16     | 604.16     | 604.16     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1063     | 0.1063     | 0.1063     |   0.0 |  0.02
Output  | 0.0002047  | 0.0002047  | 0.0002047  |   0.0 |  0.00
Modify  | 0.44584    | 0.44584    | 0.44584    |   0.0 |  0.07
Other   |            | 0.06579    |            |       |  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:      128438.0 ave      128438 max      128438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128438
Ave neighs/atom = 64.219000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.391051143337, Press = 2.11500239060983
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   -16040.759   -16040.759   -16113.426   -16113.426    281.22985    281.22985    36119.165    36119.165    2959.1008    2959.1008 
   18000   -16040.361   -16040.361    -16112.12    -16112.12    277.71386    277.71386    36202.067    36202.067   -1350.7282   -1350.7282 
Loop time of 603.497 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.638 hours/ns, 1.657 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    | 602.88     | 602.88     | 602.88     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10737    | 0.10737    | 0.10737    |   0.0 |  0.02
Output  | 0.00015689 | 0.00015689 | 0.00015689 |   0.0 |  0.00
Modify  | 0.44122    | 0.44122    | 0.44122    |   0.0 |  0.07
Other   |            | 0.06622    |            |       |  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:      128428.0 ave      128428 max      128428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128428
Ave neighs/atom = 64.214000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.405843079967, Press = 2.22142302515362
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   -16040.361   -16040.361    -16112.12    -16112.12    277.71386    277.71386    36202.067    36202.067   -1350.7282   -1350.7282 
   19000   -16038.094   -16038.094    -16109.08    -16109.08    274.72308    274.72308    36203.321    36203.321   -1246.7337   -1246.7337 
Loop time of 599.97 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.658 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.36     | 599.36     | 599.36     |   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.00020004 | 0.00020004 | 0.00020004 |   0.0 |  0.00
Modify  | 0.43982    | 0.43982    | 0.43982    |   0.0 |  0.07
Other   |            | 0.06452    |            |       |  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:      128334.0 ave      128334 max      128334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128334
Ave neighs/atom = 64.167000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.394313015625, Press = 0.3517579042654
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   -16038.094   -16038.094    -16109.08    -16109.08    274.72308    274.72308    36203.321    36203.321   -1246.7337   -1246.7337 
   20000   -16040.338   -16040.338    -16114.03    -16114.03    285.19732    285.19732    36152.252    36152.252     1187.552     1187.552 
Loop time of 541.304 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.160 ns/day, 150.362 hours/ns, 1.847 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    | 540.78     | 540.78     | 540.78     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096505   | 0.096505   | 0.096505   |   0.0 |  0.02
Output  | 0.0001531  | 0.0001531  | 0.0001531  |   0.0 |  0.00
Modify  | 0.36553    | 0.36553    | 0.36553    |   0.0 |  0.07
Other   |            | 0.05899    |            |       |  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:      128452.0 ave      128452 max      128452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128452
Ave neighs/atom = 64.226000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.497306461942, Press = 1.99326410816559
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   -16040.338   -16040.338    -16114.03    -16114.03    285.19732    285.19732    36152.252    36152.252     1187.552     1187.552 
   21000   -16042.846   -16042.846    -16110.06    -16110.06    260.12572    260.12572    36188.659    36188.659    -778.5876    -778.5876 
Loop time of 566.421 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.153 ns/day, 157.339 hours/ns, 1.765 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    | 565.86     | 565.86     | 565.86     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099681   | 0.099681   | 0.099681   |   0.0 |  0.02
Output  | 0.00019416 | 0.00019416 | 0.00019416 |   0.0 |  0.00
Modify  | 0.3954     | 0.3954     | 0.3954     |   0.0 |  0.07
Other   |            | 0.06181    |            |       |  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:      128374.0 ave      128374 max      128374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128374
Ave neighs/atom = 64.187000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.516258708795, Press = 1.17478948050174
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   -16042.846   -16042.846    -16110.06    -16110.06    260.12572    260.12572    36188.659    36188.659    -778.5876    -778.5876 
   22000   -16042.054   -16042.054   -16113.352   -16113.352    275.92726    275.92726    36183.676    36183.676   -583.41522   -583.41522 
Loop time of 535.021 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.161 ns/day, 148.617 hours/ns, 1.869 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    | 534.51     | 534.51     | 534.51     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095004   | 0.095004   | 0.095004   |   0.0 |  0.02
Output  | 0.00015795 | 0.00015795 | 0.00015795 |   0.0 |  0.00
Modify  | 0.35819    | 0.35819    | 0.35819    |   0.0 |  0.07
Other   |            | 0.05889    |            |       |  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:      128486.0 ave      128486 max      128486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128486
Ave neighs/atom = 64.243000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.506832319131, Press = 1.88314722313337
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   -16042.054   -16042.054   -16113.352   -16113.352    275.92726    275.92726    36183.676    36183.676   -583.41522   -583.41522 
   23000   -16038.604   -16038.604   -16111.272   -16111.272    281.23454    281.23454    36167.092    36167.092    618.05259    618.05259 
Loop time of 530.889 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.163 ns/day, 147.469 hours/ns, 1.884 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    | 530.38     | 530.38     | 530.38     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093986   | 0.093986   | 0.093986   |   0.0 |  0.02
Output  | 0.00015485 | 0.00015485 | 0.00015485 |   0.0 |  0.00
Modify  | 0.35222    | 0.35222    | 0.35222    |   0.0 |  0.07
Other   |            | 0.05972    |            |       |  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:      128388.0 ave      128388 max      128388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128388
Ave neighs/atom = 64.194000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.505667145942, Press = 0.225645490533981
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   -16038.604   -16038.604   -16111.272   -16111.272    281.23454    281.23454    36167.092    36167.092    618.05259    618.05259 
   24000   -16042.742   -16042.742   -16114.088   -16114.088    276.11521    276.11521    36201.852    36201.852    -1674.445    -1674.445 
Loop time of 581.675 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.149 ns/day, 161.576 hours/ns, 1.719 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    | 581.1      | 581.1      | 581.1      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10177    | 0.10177    | 0.10177    |   0.0 |  0.02
Output  | 0.00015804 | 0.00015804 | 0.00015804 |   0.0 |  0.00
Modify  | 0.41267    | 0.41267    | 0.41267    |   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:      128420.0 ave      128420 max      128420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128420
Ave neighs/atom = 64.210000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.526219294151, Press = 0.140510217192803
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   -16042.742   -16042.742   -16114.088   -16114.088    276.11521    276.11521    36201.852    36201.852    -1674.445    -1674.445 
   25000   -16039.597   -16039.597   -16112.416   -16112.416    281.81744    281.81744    36130.308    36130.308    2269.5756    2269.5756 
Loop time of 602.797 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.444 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.17     | 602.17     | 602.17     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.108      | 0.108      | 0.108      |   0.0 |  0.02
Output  | 0.00019596 | 0.00019596 | 0.00019596 |   0.0 |  0.00
Modify  | 0.4472     | 0.4472     | 0.4472     |   0.0 |  0.07
Other   |            | 0.06723    |            |       |  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 = 273.479693342539, Press = 1.09563885600879
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   -16039.597   -16039.597   -16112.416   -16112.416    281.81744    281.81744    36130.308    36130.308    2269.5756    2269.5756 
   26000   -16045.259   -16045.259   -16113.771   -16113.771    265.15007    265.15007    36174.447    36174.447   -217.21822   -217.21822 
Loop time of 576.445 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.150 ns/day, 160.124 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.87     | 575.87     | 575.87     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10194    | 0.10194    | 0.10194    |   0.0 |  0.02
Output  | 0.00015626 | 0.00015626 | 0.00015626 |   0.0 |  0.00
Modify  | 0.4089     | 0.4089     | 0.4089     |   0.0 |  0.07
Other   |            | 0.06335    |            |       |  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:      128500.0 ave      128500 max      128500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128500
Ave neighs/atom = 64.250000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.424207580728, Press = 2.83473978635177
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   -16045.259   -16045.259   -16113.771   -16113.771    265.15007    265.15007    36174.447    36174.447   -217.21822   -217.21822 
   27000   -16041.491   -16041.491   -16109.695   -16109.695    263.95688    263.95688    36216.068    36216.068   -2011.8635   -2011.8635 
Loop time of 599.866 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.629 hours/ns, 1.667 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    | 599.25     | 599.25     | 599.25     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10768    | 0.10768    | 0.10768    |   0.0 |  0.02
Output  | 0.0002408  | 0.0002408  | 0.0002408  |   0.0 |  0.00
Modify  | 0.44182    | 0.44182    | 0.44182    |   0.0 |  0.07
Other   |            | 0.06656    |            |       |  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:      128386.0 ave      128386 max      128386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128386
Ave neighs/atom = 64.193000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.318301567257, Press = 0.732250075553338
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   -16041.491   -16041.491   -16109.695   -16109.695    263.95688    263.95688    36216.068    36216.068   -2011.8635   -2011.8635 
   28000   -16038.372   -16038.372    -16110.36    -16110.36    278.60057    278.60057     36214.64     36214.64     -1886.01     -1886.01 
Loop time of 569.882 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.152 ns/day, 158.301 hours/ns, 1.755 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    | 569.32     | 569.32     | 569.32     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10099    | 0.10099    | 0.10099    |   0.0 |  0.02
Output  | 0.00015507 | 0.00015507 | 0.00015507 |   0.0 |  0.00
Modify  | 0.40146    | 0.40146    | 0.40146    |   0.0 |  0.07
Other   |            | 0.06364    |            |       |  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:      128400.0 ave      128400 max      128400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128400
Ave neighs/atom = 64.200000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.281496887155, Press = 0.597753742203626
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   -16038.372   -16038.372    -16110.36    -16110.36    278.60057    278.60057     36214.64     36214.64     -1886.01     -1886.01 
   29000   -16042.949   -16042.949   -16113.867   -16113.867    274.46058    274.46058     36131.41     36131.41    2153.5505    2153.5505 
Loop time of 577.805 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.150 ns/day, 160.501 hours/ns, 1.731 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    | 577.23     | 577.23     | 577.23     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10243    | 0.10243    | 0.10243    |   0.0 |  0.02
Output  | 0.00019255 | 0.00019255 | 0.00019255 |   0.0 |  0.00
Modify  | 0.40902    | 0.40902    | 0.40902    |   0.0 |  0.07
Other   |            | 0.06362    |            |       |  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:      128368.0 ave      128368 max      128368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128368
Ave neighs/atom = 64.184000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.249537409933, Press = -0.431277732749475
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   -16042.949   -16042.949   -16113.867   -16113.867    274.46058    274.46058     36131.41     36131.41    2153.5505    2153.5505 
   30000   -16041.238   -16041.238   -16109.846   -16109.846    265.51884    265.51884    36180.777    36180.777   -199.65243   -199.65243 
Loop time of 590.53 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 164.036 hours/ns, 1.693 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    | 589.93     | 589.93     | 589.93     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10598    | 0.10598    | 0.10598    |   0.0 |  0.02
Output  | 0.00023771 | 0.00023771 | 0.00023771 |   0.0 |  0.00
Modify  | 0.42799    | 0.42799    | 0.42799    |   0.0 |  0.07
Other   |            | 0.06563    |            |       |  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:      128404.0 ave      128404 max      128404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128404
Ave neighs/atom = 64.202000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.27894801756, Press = 1.85655604189782
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   -16041.238   -16041.238   -16109.846   -16109.846    265.51884    265.51884    36180.777    36180.777   -199.65243   -199.65243 
   31000   -16042.037   -16042.037   -16110.622   -16110.622    265.42885    265.42885    36181.785    36181.785   -303.01482   -303.01482 
Loop time of 589.401 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.722 hours/ns, 1.697 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    | 588.81     | 588.81     | 588.81     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1039     | 0.1039     | 0.1039     |   0.0 |  0.02
Output  | 0.00015564 | 0.00015564 | 0.00015564 |   0.0 |  0.00
Modify  | 0.42571    | 0.42571    | 0.42571    |   0.0 |  0.07
Other   |            | 0.06466    |            |       |  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:      128462.0 ave      128462 max      128462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128462
Ave neighs/atom = 64.231000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.23171870753, Press = 1.13349416795673
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   -16042.037   -16042.037   -16110.622   -16110.622    265.42885    265.42885    36181.785    36181.785   -303.01482   -303.01482 
   32000   -16040.602   -16040.602   -16109.582   -16109.582    266.95871    266.95871    36203.191    36203.191   -1301.7396   -1301.7396 
Loop time of 588.78 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.550 hours/ns, 1.698 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    | 588.19     | 588.19     | 588.19     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10195    | 0.10195    | 0.10195    |   0.0 |  0.02
Output  | 0.00018674 | 0.00018674 | 0.00018674 |   0.0 |  0.00
Modify  | 0.41862    | 0.41862    | 0.41862    |   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:      128490.0 ave      128490 max      128490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128490
Ave neighs/atom = 64.245000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.246329627248, Press = 1.0021925108465
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   -16040.602   -16040.602   -16109.582   -16109.582    266.95871    266.95871    36203.191    36203.191   -1301.7396   -1301.7396 
   33000    -16042.33    -16042.33   -16112.024   -16112.024     269.7225     269.7225    36184.548    36184.548   -487.36114   -487.36114 
Loop time of 599.151 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.431 hours/ns, 1.669 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    | 598.55     | 598.55     | 598.55     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10369    | 0.10369    | 0.10369    |   0.0 |  0.02
Output  | 0.00015822 | 0.00015822 | 0.00015822 |   0.0 |  0.00
Modify  | 0.43429    | 0.43429    | 0.43429    |   0.0 |  0.07
Other   |            | 0.06523    |            |       |  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:      128412.0 ave      128412 max      128412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128412
Ave neighs/atom = 64.206000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.215781058703, Press = -1.13556587575101
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 
   33000    -16042.33    -16042.33   -16112.024   -16112.024     269.7225     269.7225    36184.548    36184.548   -487.36114   -487.36114 
   34000   -16039.069   -16039.069   -16109.681   -16109.681    273.27383    273.27383    36130.111    36130.111    2547.8479    2547.8479 
Loop time of 579.638 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.149 ns/day, 161.011 hours/ns, 1.725 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    | 579.06     | 579.06     | 579.06     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1016     | 0.1016     | 0.1016     |   0.0 |  0.02
Output  | 0.000196   | 0.000196   | 0.000196   |   0.0 |  0.00
Modify  | 0.41289    | 0.41289    | 0.41289    |   0.0 |  0.07
Other   |            | 0.06296    |            |       |  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:      128428.0 ave      128428 max      128428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128428
Ave neighs/atom = 64.214000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.185211922444, Press = 0.923974783152473
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 
   34000   -16039.069   -16039.069   -16109.681   -16109.681    273.27383    273.27383    36130.111    36130.111    2547.8479    2547.8479 
   35000   -16043.313   -16043.313   -16111.262   -16111.262    262.96922    262.96922    36189.519    36189.519   -689.38401   -689.38401 
Loop time of 585.561 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.148 ns/day, 162.656 hours/ns, 1.708 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.97     | 584.97     | 584.97     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1026     | 0.1026     | 0.1026     |   0.0 |  0.02
Output  | 0.00015545 | 0.00015545 | 0.00015545 |   0.0 |  0.00
Modify  | 0.42024    | 0.42024    | 0.42024    |   0.0 |  0.07
Other   |            | 0.06358    |            |       |  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:      128528.0 ave      128528 max      128528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128528
Ave neighs/atom = 64.264000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.119505844026, Press = 1.49749643470195
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 
   35000   -16043.313   -16043.313   -16111.262   -16111.262    262.96922    262.96922    36189.519    36189.519   -689.38401   -689.38401 
   36000   -16042.954   -16042.954   -16111.529   -16111.529    265.39136    265.39136    36197.371    36197.371   -1194.5826   -1194.5826 
Loop time of 606.436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.142 ns/day, 168.454 hours/ns, 1.649 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    | 605.82     | 605.82     | 605.82     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10562    | 0.10562    | 0.10562    |   0.0 |  0.02
Output  | 0.00015469 | 0.00015469 | 0.00015469 |   0.0 |  0.00
Modify  | 0.44571    | 0.44571    | 0.44571    |   0.0 |  0.07
Other   |            | 0.06516    |            |       |  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:      128356.0 ave      128356 max      128356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0