# 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.6133156493306164*${_u_distance}
variable latticeconst_converted equal 3.6133156493306164*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331564933062
Lattice spacing in x,y,z = 3.6133156 3.6133156 3.6133156
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 (36.133156 36.133156 36.133156)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.133156 36.133156 36.133156)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimLee_2008_CuZr__MO_407917731909_000
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47175.6297173106 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_407917731909_000#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -14018.806   -14018.806       -14160       -14160       273.15       273.15     47175.63     47175.63     3196.821     3196.821 
    1000   -13870.076   -13870.076   -14014.445   -14014.445    279.29183    279.29183    47934.911    47934.911   -1401.2822   -1401.2822 
Loop time of 396.884 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 110.245 hours/ns, 2.520 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    | 395.86     | 395.86     | 395.86     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16081    | 0.16081    | 0.16081    |   0.0 |  0.04
Output  | 0.00021789 | 0.00021789 | 0.00021789 |   0.0 |  0.00
Modify  | 0.75964    | 0.75964    | 0.75964    |   0.0 |  0.19
Other   |            | 0.1038     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      536000.0 ave      536000 max      536000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 536000
Ave neighs/atom = 134.00000
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13870.076   -13870.076   -14014.445   -14014.445    279.29183    279.29183    47934.911    47934.911   -1401.2822   -1401.2822 
    2000   -13879.752   -13879.752   -14022.361   -14022.361    275.88555    275.88555    47875.069    47875.069   -480.35121   -480.35121 
Loop time of 419.272 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.464 hours/ns, 2.385 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    | 418.21     | 418.21     | 418.21     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16607    | 0.16607    | 0.16607    |   0.0 |  0.04
Output  | 0.00021738 | 0.00021738 | 0.00021738 |   0.0 |  0.00
Modify  | 0.7903     | 0.7903     | 0.7903     |   0.0 |  0.19
Other   |            | 0.1059     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      530540.0 ave      530540 max      530540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530540
Ave neighs/atom = 132.63500
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13879.752   -13879.752   -14022.361   -14022.361    275.88555    275.88555    47875.069    47875.069   -480.35121   -480.35121 
    3000   -13877.049   -13877.049   -14021.487   -14021.487    279.42415    279.42415    47890.152    47890.152   -639.83313   -639.83313 
Loop time of 409.668 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.797 hours/ns, 2.441 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    | 408.64     | 408.64     | 408.64     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16574    | 0.16574    | 0.16574    |   0.0 |  0.04
Output  | 0.00033541 | 0.00033541 | 0.00033541 |   0.0 |  0.00
Modify  | 0.76082    | 0.76082    | 0.76082    |   0.0 |  0.19
Other   |            | 0.1042     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531896.0 ave      531896 max      531896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531896
Ave neighs/atom = 132.97400
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13877.049   -13877.049   -14021.487   -14021.487    279.42415    279.42415    47890.152    47890.152   -639.83313   -639.83313 
    4000    -13877.12    -13877.12   -14018.007   -14018.007    272.55582    272.55582    47905.817    47905.817   -856.44913   -856.44913 
Loop time of 370.4 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.889 hours/ns, 2.700 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    | 369.49     | 369.49     | 369.49     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14818    | 0.14818    | 0.14818    |   0.0 |  0.04
Output  | 0.00026784 | 0.00026784 | 0.00026784 |   0.0 |  0.00
Modify  | 0.66039    | 0.66039    | 0.66039    |   0.0 |  0.18
Other   |            | 0.09651    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531992.0 ave      531992 max      531992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531992
Ave neighs/atom = 132.99800
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000    -13877.12    -13877.12   -14018.007   -14018.007    272.55582    272.55582    47905.817    47905.817   -856.44913   -856.44913 
    5000    -13880.22    -13880.22   -14017.363   -14017.363    265.31181    265.31181    47860.951    47860.951    513.55638    513.55638 
Loop time of 366.529 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.814 hours/ns, 2.728 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    | 365.64     | 365.64     | 365.64     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14889    | 0.14889    | 0.14889    |   0.0 |  0.04
Output  | 0.00018009 | 0.00018009 | 0.00018009 |   0.0 |  0.00
Modify  | 0.64851    | 0.64851    | 0.64851    |   0.0 |  0.18
Other   |            | 0.0949     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531344.0 ave      531344 max      531344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531344
Ave neighs/atom = 132.83600
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 = 274.452430988879, Press = 727.423261100719
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000    -13880.22    -13880.22   -14017.363   -14017.363    265.31181    265.31181    47860.951    47860.951    513.55638    513.55638 
    6000   -13874.143   -13874.143   -14020.344   -14020.344    282.83644    282.83644    47823.358    47823.358    1491.2034    1491.2034 
Loop time of 363.692 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 101.025 hours/ns, 2.750 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    | 362.79     | 362.79     | 362.79     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14285    | 0.14285    | 0.14285    |   0.0 |  0.04
Output  | 0.00022604 | 0.00022604 | 0.00022604 |   0.0 |  0.00
Modify  | 0.66366    | 0.66366    | 0.66366    |   0.0 |  0.18
Other   |            | 0.09795    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5847.00 ave        5847 max        5847 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:      531754.0 ave      531754 max      531754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531754
Ave neighs/atom = 132.93850
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.610071930302, Press = 17.7903659552992
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13874.143   -13874.143   -14020.344   -14020.344    282.83644    282.83644    47823.358    47823.358    1491.2034    1491.2034 
    7000   -13880.514   -13880.514   -14019.502   -14019.502    268.88252    268.88252    47908.507    47908.507   -1036.1862   -1036.1862 
Loop time of 385.534 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.093 hours/ns, 2.594 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    | 384.57     | 384.57     | 384.57     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14963    | 0.14963    | 0.14963    |   0.0 |  0.04
Output  | 0.00023149 | 0.00023149 | 0.00023149 |   0.0 |  0.00
Modify  | 0.71647    | 0.71647    | 0.71647    |   0.0 |  0.19
Other   |            | 0.1007     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      532250.0 ave      532250 max      532250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532250
Ave neighs/atom = 133.06250
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.0121144884, Press = -4.48328202074888
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13880.514   -13880.514   -14019.502   -14019.502    268.88252    268.88252    47908.507    47908.507   -1036.1862   -1036.1862 
    8000    -13879.31    -13879.31    -14018.24    -14018.24    268.76918    268.76918    47900.154    47900.154   -711.71958   -711.71958 
Loop time of 429.312 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.253 hours/ns, 2.329 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    | 428.19     | 428.19     | 428.19     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16691    | 0.16691    | 0.16691    |   0.0 |  0.04
Output  | 0.00018123 | 0.00018123 | 0.00018123 |   0.0 |  0.00
Modify  | 0.84291    | 0.84291    | 0.84291    |   0.0 |  0.20
Other   |            | 0.1079     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531768.0 ave      531768 max      531768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531768
Ave neighs/atom = 132.94200
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.088072688226, Press = 19.9536975900456
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000    -13879.31    -13879.31    -14018.24    -14018.24    268.76918    268.76918    47900.154    47900.154   -711.71958   -711.71958 
    9000   -13873.264   -13873.264   -14014.598   -14014.598    273.41891    273.41891     47847.43     47847.43    1351.3954    1351.3954 
Loop time of 402.42 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.215 ns/day, 111.783 hours/ns, 2.485 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    | 401.4      | 401.4      | 401.4      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15598    | 0.15598    | 0.15598    |   0.0 |  0.04
Output  | 0.00022936 | 0.00022936 | 0.00022936 |   0.0 |  0.00
Modify  | 0.76456    | 0.76456    | 0.76456    |   0.0 |  0.19
Other   |            | 0.1032     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531408.0 ave      531408 max      531408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531408
Ave neighs/atom = 132.85200
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.383464329876, Press = 12.2281066533576
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13873.264   -13873.264   -14014.598   -14014.598    273.41891    273.41891     47847.43     47847.43    1351.3954    1351.3954 
   10000   -13875.848   -13875.848   -14016.169   -14016.169    271.46094    271.46094    47872.004    47872.004    394.42789    394.42789 
Loop time of 411.394 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.276 hours/ns, 2.431 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    | 410.34     | 410.34     | 410.34     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16097    | 0.16097    | 0.16097    |   0.0 |  0.04
Output  | 0.00027755 | 0.00027755 | 0.00027755 |   0.0 |  0.00
Modify  | 0.78916    | 0.78916    | 0.78916    |   0.0 |  0.19
Other   |            | 0.1048     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      531758.0 ave      531758 max      531758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531758
Ave neighs/atom = 132.93950
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.298218951416, Press = 4.1125820404626
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13875.848   -13875.848   -14016.169   -14016.169    271.46094    271.46094    47872.004    47872.004    394.42789    394.42789 
   11000    -13880.74    -13880.74     -14018.7     -14018.7    266.89318    266.89318    47903.178    47903.178   -896.70159   -896.70159 
Loop time of 400.715 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.310 hours/ns, 2.496 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    | 399.7      | 399.7      | 399.7      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15839    | 0.15839    | 0.15839    |   0.0 |  0.04
Output  | 0.00018255 | 0.00018255 | 0.00018255 |   0.0 |  0.00
Modify  | 0.75918    | 0.75918    | 0.75918    |   0.0 |  0.19
Other   |            | 0.1026     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531570.0 ave      531570 max      531570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531570
Ave neighs/atom = 132.89250
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.181711248316, Press = 2.01455277653718
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000    -13880.74    -13880.74     -14018.7     -14018.7    266.89318    266.89318    47903.178    47903.178   -896.70159   -896.70159 
   12000   -13879.029   -13879.029   -14019.863   -14019.863     272.4539     272.4539    47887.829    47887.829   -429.56146   -429.56146 
Loop time of 419.023 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.395 hours/ns, 2.387 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    | 417.95     | 417.95     | 417.95     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16211    | 0.16211    | 0.16211    |   0.0 |  0.04
Output  | 0.00028452 | 0.00028452 | 0.00028452 |   0.0 |  0.00
Modify  | 0.80118    | 0.80118    | 0.80118    |   0.0 |  0.19
Other   |            | 0.1062     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531558.0 ave      531558 max      531558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531558
Ave neighs/atom = 132.88950
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.921835114044, Press = 11.4619202794839
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13879.029   -13879.029   -14019.863   -14019.863     272.4539     272.4539    47887.829    47887.829   -429.56146   -429.56146 
   13000   -13879.086   -13879.086    -14020.59    -14020.59    273.74982    273.74982    47798.836    47798.836    2059.7515    2059.7515 
Loop time of 430.125 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.479 hours/ns, 2.325 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    | 429.04     | 429.04     | 429.04     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16409    | 0.16409    | 0.16409    |   0.0 |  0.04
Output  | 0.00023136 | 0.00023136 | 0.00023136 |   0.0 |  0.00
Modify  | 0.81483    | 0.81483    | 0.81483    |   0.0 |  0.19
Other   |            | 0.107      |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531802.0 ave      531802 max      531802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531802
Ave neighs/atom = 132.95050
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.939817005842, Press = 2.55585632935541
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13879.086   -13879.086    -14020.59    -14020.59    273.74982    273.74982    47798.836    47798.836    2059.7515    2059.7515 
   14000   -13872.139   -13872.139   -14013.705   -14013.705    273.86901    273.86901    47913.934    47913.934    -537.4531    -537.4531 
Loop time of 382.641 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.289 hours/ns, 2.613 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    | 381.68     | 381.68     | 381.68     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15056    | 0.15056    | 0.15056    |   0.0 |  0.04
Output  | 0.00022543 | 0.00022543 | 0.00022543 |   0.0 |  0.00
Modify  | 0.71164    | 0.71164    | 0.71164    |   0.0 |  0.19
Other   |            | 0.09899    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      532336.0 ave      532336 max      532336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532336
Ave neighs/atom = 133.08400
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.053853924731, Press = 0.995174333398772
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13872.139   -13872.139   -14013.705   -14013.705    273.86901    273.86901    47913.934    47913.934    -537.4531    -537.4531 
   15000   -13879.089   -13879.089   -14019.724   -14019.724    272.06775    272.06775    47872.854    47872.854   -92.950777   -92.950777 
Loop time of 365.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.605 hours/ns, 2.734 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 364.87     | 364.87     | 364.87     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14559    | 0.14559    | 0.14559    |   0.0 |  0.04
Output  | 0.00018231 | 0.00018231 | 0.00018231 |   0.0 |  0.00
Modify  | 0.66644    | 0.66644    | 0.66644    |   0.0 |  0.18
Other   |            | 0.09547    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531258.0 ave      531258 max      531258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531258
Ave neighs/atom = 132.81450
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.187709062327, Press = 3.89263003441673
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13879.089   -13879.089   -14019.724   -14019.724    272.06775    272.06775    47872.854    47872.854   -92.950777   -92.950777 
   16000   -13882.528   -13882.528   -14022.503   -14022.503    270.79034    270.79034    47843.467    47843.467    497.13278    497.13278 
Loop time of 421.28 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.022 hours/ns, 2.374 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    | 420.2      | 420.2      | 420.2      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16225    | 0.16225    | 0.16225    |   0.0 |  0.04
Output  | 0.00025022 | 0.00025022 | 0.00025022 |   0.0 |  0.00
Modify  | 0.81011    | 0.81011    | 0.81011    |   0.0 |  0.19
Other   |            | 0.1065     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531674.0 ave      531674 max      531674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531674
Ave neighs/atom = 132.91850
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.15921576263, Press = 3.819703519853
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13882.528   -13882.528   -14022.503   -14022.503    270.79034    270.79034    47843.467    47843.467    497.13278    497.13278 
   17000   -13874.867   -13874.867   -14016.188   -14016.188    273.39427    273.39427     47860.69     47860.69    750.31141    750.31141 
Loop time of 429.83 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.397 hours/ns, 2.327 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    | 428.73     | 428.73     | 428.73     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16603    | 0.16603    | 0.16603    |   0.0 |  0.04
Output  | 0.00017803 | 0.00017803 | 0.00017803 |   0.0 |  0.00
Modify  | 0.82862    | 0.82862    | 0.82862    |   0.0 |  0.19
Other   |            | 0.1076     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      532044.0 ave      532044 max      532044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532044
Ave neighs/atom = 133.01100
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.066202334935, Press = 1.51870610316941
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13874.867   -13874.867   -14016.188   -14016.188    273.39427    273.39427     47860.69     47860.69    750.31141    750.31141 
   18000    -13878.81    -13878.81   -14019.492   -14019.492    272.15869    272.15869    47904.386    47904.386   -991.15901   -991.15901 
Loop time of 430.181 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.495 hours/ns, 2.325 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    | 429.07     | 429.07     | 429.07     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16602    | 0.16602    | 0.16602    |   0.0 |  0.04
Output  | 0.00017906 | 0.00017906 | 0.00017906 |   0.0 |  0.00
Modify  | 0.83336    | 0.83336    | 0.83336    |   0.0 |  0.19
Other   |            | 0.1081     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531554.0 ave      531554 max      531554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531554
Ave neighs/atom = 132.88850
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.204850460819, Press = 0.325162978598218
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000    -13878.81    -13878.81   -14019.492   -14019.492    272.15869    272.15869    47904.386    47904.386   -991.15901   -991.15901 
   19000    -13872.72    -13872.72   -14012.955   -14012.955    271.29532    271.29532    47911.961    47911.961   -450.02679   -450.02679 
Loop time of 370.344 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.873 hours/ns, 2.700 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    | 369.42     | 369.42     | 369.42     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14721    | 0.14721    | 0.14721    |   0.0 |  0.04
Output  | 0.00023255 | 0.00023255 | 0.00023255 |   0.0 |  0.00
Modify  | 0.6834     | 0.6834     | 0.6834     |   0.0 |  0.18
Other   |            | 0.09628    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531640.0 ave      531640 max      531640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531640
Ave neighs/atom = 132.91000
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.269261529104, Press = 4.25922467696243
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -13872.72    -13872.72   -14012.955   -14012.955    271.29532    271.29532    47911.961    47911.961   -450.02679   -450.02679 
   20000   -13879.982   -13879.982   -14021.678   -14021.678    274.12128    274.12128    47799.831    47799.831    1864.1979    1864.1979 
Loop time of 421.445 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.068 hours/ns, 2.373 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    | 420.37     | 420.37     | 420.37     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16323    | 0.16323    | 0.16323    |   0.0 |  0.04
Output  | 0.00018244 | 0.00018244 | 0.00018244 |   0.0 |  0.00
Modify  | 0.80789    | 0.80789    | 0.80789    |   0.0 |  0.19
Other   |            | 0.1064     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      530964.0 ave      530964 max      530964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530964
Ave neighs/atom = 132.74100
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.319549809831, Press = 2.33974774278399
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13879.982   -13879.982   -14021.678   -14021.678    274.12128    274.12128    47799.831    47799.831    1864.1979    1864.1979 
   21000   -13877.003   -13877.003    -14019.34    -14019.34    275.36042    275.36042    47891.125    47891.125   -392.52963   -392.52963 
Loop time of 364.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.372 hours/ns, 2.740 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    | 364.03     | 364.03     | 364.03     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14686    | 0.14686    | 0.14686    |   0.0 |  0.04
Output  | 0.00017982 | 0.00017982 | 0.00017982 |   0.0 |  0.00
Modify  | 0.66756    | 0.66756    | 0.66756    |   0.0 |  0.18
Other   |            | 0.09519    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      532356.0 ave      532356 max      532356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532356
Ave neighs/atom = 133.08900
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.260856725513, Press = -1.96452991264579
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13877.003   -13877.003    -14019.34    -14019.34    275.36042    275.36042    47891.125    47891.125   -392.52963   -392.52963 
   22000   -13880.465   -13880.465   -14019.797   -14019.797    269.54756    269.54756      47924.8      47924.8   -1613.7083   -1613.7083 
Loop time of 364.062 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.128 hours/ns, 2.747 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    | 363.15     | 363.15     | 363.15     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14197    | 0.14197    | 0.14197    |   0.0 |  0.04
Output  | 0.00022722 | 0.00022722 | 0.00022722 |   0.0 |  0.00
Modify  | 0.66713    | 0.66713    | 0.66713    |   0.0 |  0.18
Other   |            | 0.0979     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531688.0 ave      531688 max      531688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531688
Ave neighs/atom = 132.92200
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.239011353857, Press = 3.04431295743859
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13880.465   -13880.465   -14019.797   -14019.797    269.54756    269.54756      47924.8      47924.8   -1613.7083   -1613.7083 
   23000   -13878.934   -13878.934   -14017.408   -14017.408    267.88839    267.88839    47845.336    47845.336    1015.4627    1015.4627 
Loop time of 388.771 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 107.992 hours/ns, 2.572 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    | 387.79     | 387.79     | 387.79     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1486     | 0.1486     | 0.1486     |   0.0 |  0.04
Output  | 0.00017912 | 0.00017912 | 0.00017912 |   0.0 |  0.00
Modify  | 0.72882    | 0.72882    | 0.72882    |   0.0 |  0.19
Other   |            | 0.09911    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531570.0 ave      531570 max      531570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531570
Ave neighs/atom = 132.89250
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.260730976126, Press = 2.6915566705017
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13878.934   -13878.934   -14017.408   -14017.408    267.88839    267.88839    47845.336    47845.336    1015.4627    1015.4627 
   24000    -13874.98    -13874.98   -14018.224   -14018.224    277.11578    277.11578    47867.732    47867.732    390.53569    390.53569 
Loop time of 386.211 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.281 hours/ns, 2.589 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    | 385.24     | 385.24     | 385.24     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14914    | 0.14914    | 0.14914    |   0.0 |  0.04
Output  | 0.00018132 | 0.00018132 | 0.00018132 |   0.0 |  0.00
Modify  | 0.71858    | 0.71858    | 0.71858    |   0.0 |  0.19
Other   |            | 0.0992     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531922.0 ave      531922 max      531922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531922
Ave neighs/atom = 132.98050
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.246216783946, Press = 0.79972368516867
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000    -13874.98    -13874.98   -14018.224   -14018.224    277.11578    277.11578    47867.732    47867.732    390.53569    390.53569 
   25000   -13882.174   -13882.174   -14018.832   -14018.832    264.37439    264.37439    47900.992    47900.992   -788.68006   -788.68006 
Loop time of 393.982 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.440 hours/ns, 2.538 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    | 392.99     | 392.99     | 392.99     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15127    | 0.15127    | 0.15127    |   0.0 |  0.04
Output  | 0.00018177 | 0.00018177 | 0.00018177 |   0.0 |  0.00
Modify  | 0.74169    | 0.74169    | 0.74169    |   0.0 |  0.19
Other   |            | 0.09995    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531830.0 ave      531830 max      531830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531830
Ave neighs/atom = 132.95750
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.200393844709, Press = 0.639205232314355
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13882.174   -13882.174   -14018.832   -14018.832    264.37439    264.37439    47900.992    47900.992   -788.68006   -788.68006 
   26000   -13877.006   -13877.006   -14016.951   -14016.951    270.73362    270.73362    47891.837    47891.837   -182.24939   -182.24939 
Loop time of 365.148 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.430 hours/ns, 2.739 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    | 364.24     | 364.24     | 364.24     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14569    | 0.14569    | 0.14569    |   0.0 |  0.04
Output  | 0.00018664 | 0.00018664 | 0.00018664 |   0.0 |  0.00
Modify  | 0.66984    | 0.66984    | 0.66984    |   0.0 |  0.18
Other   |            | 0.09274    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531706.0 ave      531706 max      531706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531706
Ave neighs/atom = 132.92650
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.138107019489, Press = 4.76830629995961
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13877.006   -13877.006   -14016.951   -14016.951    270.73362    270.73362    47891.837    47891.837   -182.24939   -182.24939 
   27000   -13882.515   -13882.515   -14019.049   -14019.049    264.13576    264.13576    47770.688    47770.688     2917.511     2917.511 
Loop time of 365.652 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.570 hours/ns, 2.735 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    | 364.75     | 364.75     | 364.75     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14503    | 0.14503    | 0.14503    |   0.0 |  0.04
Output  | 0.0001808  | 0.0001808  | 0.0001808  |   0.0 |  0.00
Modify  | 0.66783    | 0.66783    | 0.66783    |   0.0 |  0.18
Other   |            | 0.09337    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531940.0 ave      531940 max      531940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531940
Ave neighs/atom = 132.98500
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.113056883228, Press = 1.33578041127257
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13882.515   -13882.515   -14019.049   -14019.049    264.13576    264.13576    47770.688    47770.688     2917.511     2917.511 
   28000   -13877.963   -13877.963   -14018.162   -14018.162    271.22616    271.22616    47897.665    47897.665   -471.46854   -471.46854 
Loop time of 366.464 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.796 hours/ns, 2.729 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    | 365.56     | 365.56     | 365.56     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14503    | 0.14503    | 0.14503    |   0.0 |  0.04
Output  | 0.00017829 | 0.00017829 | 0.00017829 |   0.0 |  0.00
Modify  | 0.66693    | 0.66693    | 0.66693    |   0.0 |  0.18
Other   |            | 0.093      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      532314.0 ave      532314 max      532314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532314
Ave neighs/atom = 133.07850
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.017656703647, Press = -0.313273787822651
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13877.963   -13877.963   -14018.162   -14018.162    271.22616    271.22616    47897.665    47897.665   -471.46854   -471.46854 
   29000   -13880.802   -13880.802   -14019.745   -14019.745    268.79461    268.79461    47895.213    47895.213   -755.73389   -755.73389 
Loop time of 398.034 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.217 ns/day, 110.565 hours/ns, 2.512 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    | 397.01     | 397.01     | 397.01     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1542     | 0.1542     | 0.1542     |   0.0 |  0.04
Output  | 0.00018145 | 0.00018145 | 0.00018145 |   0.0 |  0.00
Modify  | 0.76433    | 0.76433    | 0.76433    |   0.0 |  0.19
Other   |            | 0.1008     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531840.0 ave      531840 max      531840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531840
Ave neighs/atom = 132.96000
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.986633565668, Press = 2.24577573303464
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13880.802   -13880.802   -14019.745   -14019.745    268.79461    268.79461    47895.213    47895.213   -755.73389   -755.73389 
   30000   -13875.256   -13875.256   -14017.649   -14017.649    275.46883    275.46883     47843.41     47843.41    1079.0384    1079.0384 
Loop time of 404.971 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.492 hours/ns, 2.469 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    | 403.94     | 403.94     | 403.94     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15452    | 0.15452    | 0.15452    |   0.0 |  0.04
Output  | 0.00022172 | 0.00022172 | 0.00022172 |   0.0 |  0.00
Modify  | 0.76902    | 0.76902    | 0.76902    |   0.0 |  0.19
Other   |            | 0.1024     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531680.0 ave      531680 max      531680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531680
Ave neighs/atom = 132.92000
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.925838829429, Press = 1.85043035279786
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13875.256   -13875.256   -14017.649   -14017.649    275.46883    275.46883     47843.41     47843.41    1079.0384    1079.0384 
   31000    -13880.31    -13880.31   -14018.099   -14018.099    266.56373    266.56373    47844.564    47844.564    954.77601    954.77601 
Loop time of 386.193 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.276 hours/ns, 2.589 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    | 385.22     | 385.22     | 385.22     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14876    | 0.14876    | 0.14876    |   0.0 |  0.04
Output  | 0.00017974 | 0.00017974 | 0.00017974 |   0.0 |  0.00
Modify  | 0.72436    | 0.72436    | 0.72436    |   0.0 |  0.19
Other   |            | 0.09935    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      532100.0 ave      532100 max      532100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532100
Ave neighs/atom = 133.02500
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.900906671342, Press = 0.642523991929101
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000    -13880.31    -13880.31   -14018.099   -14018.099    266.56373    266.56373    47844.564    47844.564    954.77601    954.77601 
   32000   -13879.102   -13879.102   -14016.797   -14016.797    266.37891    266.37891    47938.583    47938.583    -1688.148    -1688.148 
Loop time of 420.881 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 116.911 hours/ns, 2.376 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    | 419.81     | 419.81     | 419.81     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15868    | 0.15868    | 0.15868    |   0.0 |  0.04
Output  | 0.00028324 | 0.00028324 | 0.00028324 |   0.0 |  0.00
Modify  | 0.80616    | 0.80616    | 0.80616    |   0.0 |  0.19
Other   |            | 0.1037     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531842.0 ave      531842 max      531842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531842
Ave neighs/atom = 132.96050
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.920650067885, Press = -0.363463983694276
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13879.102   -13879.102   -14016.797   -14016.797    266.37891    266.37891    47938.583    47938.583    -1688.148    -1688.148 
   33000    -13878.48    -13878.48    -14019.27    -14019.27    272.36655    272.36655    47896.078    47896.078   -566.71491   -566.71491 
Loop time of 429.815 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.393 hours/ns, 2.327 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    | 428.72     | 428.72     | 428.72     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16363    | 0.16363    | 0.16363    |   0.0 |  0.04
Output  | 0.00023123 | 0.00023123 | 0.00023123 |   0.0 |  0.00
Modify  | 0.82557    | 0.82557    | 0.82557    |   0.0 |  0.19
Other   |            | 0.1054     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531340.0 ave      531340 max      531340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531340
Ave neighs/atom = 132.83500
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.969929514368, Press = 3.07970739178206
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    -13878.48    -13878.48    -14019.27    -14019.27    272.36655    272.36655    47896.078    47896.078   -566.71491   -566.71491 
   34000    -13881.58    -13881.58   -14022.441   -14022.441    272.50529    272.50529    47826.151    47826.151    1073.4404    1073.4404 
Loop time of 392.737 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.094 hours/ns, 2.546 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    | 391.74     | 391.74     | 391.74     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15097    | 0.15097    | 0.15097    |   0.0 |  0.04
Output  | 0.00017722 | 0.00017722 | 0.00017722 |   0.0 |  0.00
Modify  | 0.74292    | 0.74292    | 0.74292    |   0.0 |  0.19
Other   |            | 0.09983    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531854.0 ave      531854 max      531854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531854
Ave neighs/atom = 132.96350
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.994618196302, Press = 1.75414630564569
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000    -13881.58    -13881.58   -14022.441   -14022.441    272.50529    272.50529    47826.151    47826.151    1073.4404    1073.4404 
   35000   -13876.544   -13876.544   -14019.166   -14019.166    275.91308    275.91308    47851.525    47851.525     734.7495     734.7495 
Loop time of 396.024 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 110.007 hours/ns, 2.525 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    | 395.03     | 395.03     | 395.03     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15267    | 0.15267    | 0.15267    |   0.0 |  0.04
Output  | 0.00017808 | 0.00017808 | 0.00017808 |   0.0 |  0.00
Modify  | 0.74594    | 0.74594    | 0.74594    |   0.0 |  0.19
Other   |            | 0.09912    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      532346.0 ave      532346 max      532346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532346
Ave neighs/atom = 133.08650
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.939314370912, Press = 0.525815151248554
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13876.544   -13876.544   -14019.166   -14019.166    275.91308    275.91308    47851.525    47851.525     734.7495     734.7495 
   36000    -13880.45    -13880.45    -14018.91    -14018.91    267.86017    267.86017    47893.541    47893.541   -641.70464   -641.70464 
Loop time of 364.928 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.369 hours/ns, 2.740 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    | 364.03     | 364.03     | 364.03     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1439     | 0.1439     | 0.1439     |   0.0 |  0.04
Output  | 0.0001828  | 0.0001828  | 0.0001828  |   0.0 |  0.00
Modify  | 0.66427    | 0.66427    | 0.66427    |   0.0 |  0.18
Other   |            | 0.09241    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      531768.0 ave      531768 max      531768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531768
Ave neighs/atom = 132.94200
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.944387206744, Press = 0.666382278925987
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000    -13880.45    -13880.45    -14018.91    -14018.91    267.86017    267.86017    47893.541    47893.541   -641.70464   -641.70464 
   37000   -13874.189   -13874.189   -14014.531   -14014.531    271.50174    271.50174    47888.734    47888.734    80.001602    80.001602 
Loop time of 364.518 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.255 hours/ns, 2.743 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    | 363.61     | 363.61     | 363.61     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14308    | 0.14308    | 0.14308    |   0.0 |  0.04
Output  | 0.00017918 | 0.00017918 | 0.00017918 |   0.0 |  0.00
Modify  | 0.66737    | 0.66737    | 0.66737    |   0.0 |  0.18
Other   |            | 0.09479    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531484.0 ave      531484 max      531484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531484
Ave neighs/atom = 132.87100
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.998810419668, Press = 1.51783046421584
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13874.189   -13874.189   -14014.531   -14014.531    271.50174    271.50174    47888.734    47888.734    80.001602    80.001602 
   38000   -13879.813   -13879.813   -14020.437   -14020.437    272.04756    272.04756    47846.661    47846.661    704.17035    704.17035 
Loop time of 363.491 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.970 hours/ns, 2.751 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    | 362.59     | 362.59     | 362.59     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14062    | 0.14062    | 0.14062    |   0.0 |  0.04
Output  | 0.00017867 | 0.00017867 | 0.00017867 |   0.0 |  0.00
Modify  | 0.66644    | 0.66644    | 0.66644    |   0.0 |  0.18
Other   |            | 0.09697    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531098.0 ave      531098 max      531098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531098
Ave neighs/atom = 132.77450
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.006024122081, Press = 0.695082512703822
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13879.813   -13879.813   -14020.437   -14020.437    272.04756    272.04756    47846.661    47846.661    704.17035    704.17035 
   39000   -13876.427   -13876.427   -14019.109   -14019.109    276.02741    276.02741    47915.455    47915.455   -1190.6958   -1190.6958 
Loop time of 363.529 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.980 hours/ns, 2.751 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    | 362.62     | 362.62     | 362.62     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14174    | 0.14174    | 0.14174    |   0.0 |  0.04
Output  | 0.0001772  | 0.0001772  | 0.0001772  |   0.0 |  0.00
Modify  | 0.66492    | 0.66492    | 0.66492    |   0.0 |  0.18
Other   |            | 0.09734    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      532126.0 ave      532126 max      532126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532126
Ave neighs/atom = 133.03150
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.005041453667, Press = 0.986588658495138
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13876.427   -13876.427   -14019.109   -14019.109    276.02741    276.02741    47915.455    47915.455   -1190.6958   -1190.6958 
   40000   -13880.262   -13880.262   -14019.893   -14019.893     270.1264     270.1264    47840.902    47840.902    856.05777    856.05777 
Loop time of 363.826 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.063 hours/ns, 2.749 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    | 362.92     | 362.92     | 362.92     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14014    | 0.14014    | 0.14014    |   0.0 |  0.04
Output  | 0.00017909 | 0.00017909 | 0.00017909 |   0.0 |  0.00
Modify  | 0.66675    | 0.66675    | 0.66675    |   0.0 |  0.18
Other   |            | 0.09596    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531380.0 ave      531380 max      531380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531380
Ave neighs/atom = 132.84500
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.955396651039, Press = 3.01294694273456
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13880.262   -13880.262   -14019.893   -14019.893     270.1264     270.1264    47840.902    47840.902    856.05777    856.05777 
   41000   -13877.034   -13877.034   -14019.735   -14019.735    276.06543    276.06543    47805.285    47805.285    1990.0118    1990.0118 
Loop time of 363.608 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 101.002 hours/ns, 2.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    | 362.7      | 362.7      | 362.7      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14069    | 0.14069    | 0.14069    |   0.0 |  0.04
Output  | 0.00017735 | 0.00017735 | 0.00017735 |   0.0 |  0.00
Modify  | 0.66734    | 0.66734    | 0.66734    |   0.0 |  0.18
Other   |            | 0.09634    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5845.00 ave        5845 max        5845 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:      531902.0 ave      531902 max      531902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531902
Ave neighs/atom = 132.97550
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.932651369964, Press = 0.236326739857977
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13877.034   -13877.034   -14019.735   -14019.735    276.06543    276.06543    47805.285    47805.285    1990.0118    1990.0118 
   42000   -13877.461   -13877.461   -14017.717   -14017.717    271.33525    271.33525    47907.742    47907.742   -877.33003   -877.33003 
Loop time of 363.389 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.941 hours/ns, 2.752 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    | 362.49     | 362.49     | 362.49     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14124    | 0.14124    | 0.14124    |   0.0 |  0.04
Output  | 0.00022679 | 0.00022679 | 0.00022679 |   0.0 |  0.00
Modify  | 0.66632    | 0.66632    | 0.66632    |   0.0 |  0.18
Other   |            | 0.09614    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      532040.0 ave      532040 max      532040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532040
Ave neighs/atom = 133.01000
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.891200429699, Press = 0.0367095295016166
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13877.461   -13877.461   -14017.717   -14017.717    271.33525    271.33525    47907.742    47907.742   -877.33003   -877.33003 
   43000   -13880.498   -13880.498   -14018.667   -14018.667    267.29731    267.29731    47917.331    47917.331   -1259.0118   -1259.0118 
Loop time of 363.551 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.986 hours/ns, 2.751 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    | 362.65     | 362.65     | 362.65     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14004    | 0.14004    | 0.14004    |   0.0 |  0.04
Output  | 0.00017821 | 0.00017821 | 0.00017821 |   0.0 |  0.00
Modify  | 0.66764    | 0.66764    | 0.66764    |   0.0 |  0.18
Other   |            | 0.09598    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531464.0 ave      531464 max      531464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531464
Ave neighs/atom = 132.86600
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.900226665947, Press = 1.76250685096799
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13880.498   -13880.498   -14018.667   -14018.667    267.29731    267.29731    47917.331    47917.331   -1259.0118   -1259.0118 
   44000   -13872.892   -13872.892   -14015.631   -14015.631    276.13768    276.13768    47848.665    47848.665    1161.3752    1161.3752 
Loop time of 363.937 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.094 hours/ns, 2.748 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    | 363.03     | 363.03     | 363.03     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14005    | 0.14005    | 0.14005    |   0.0 |  0.04
Output  | 0.00017647 | 0.00017647 | 0.00017647 |   0.0 |  0.00
Modify  | 0.66641    | 0.66641    | 0.66641    |   0.0 |  0.18
Other   |            | 0.09677    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531606.0 ave      531606 max      531606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531606
Ave neighs/atom = 132.90150
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.911728142341, Press = 1.124742704446
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -13872.892   -13872.892   -14015.631   -14015.631    276.13768    276.13768    47848.665    47848.665    1161.3752    1161.3752 
   45000   -13878.294   -13878.294   -14018.915   -14018.915      272.041      272.041    47869.282    47869.282    198.16127    198.16127 
Loop time of 364.021 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.117 hours/ns, 2.747 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    | 363.12     | 363.12     | 363.12     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14012    | 0.14012    | 0.14012    |   0.0 |  0.04
Output  | 0.00017956 | 0.00017956 | 0.00017956 |   0.0 |  0.00
Modify  | 0.66804    | 0.66804    | 0.66804    |   0.0 |  0.18
Other   |            | 0.09692    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531802.0 ave      531802 max      531802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531802
Ave neighs/atom = 132.95050
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.951830460401, Press = 0.334480571223997
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13878.294   -13878.294   -14018.915   -14018.915      272.041      272.041    47869.282    47869.282    198.16127    198.16127 
   46000    -13876.43    -13876.43   -14018.044   -14018.044    273.96202    273.96202    47899.997    47899.997   -570.35763   -570.35763 
Loop time of 364.791 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.331 hours/ns, 2.741 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    | 363.89     | 363.89     | 363.89     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14103    | 0.14103    | 0.14103    |   0.0 |  0.04
Output  | 0.00017854 | 0.00017854 | 0.00017854 |   0.0 |  0.00
Modify  | 0.66775    | 0.66775    | 0.66775    |   0.0 |  0.18
Other   |            | 0.09681    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5845.00 ave        5845 max        5845 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:      531834.0 ave      531834 max      531834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531834
Ave neighs/atom = 132.95850
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.9693043405, Press = 0.695991203742911
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000    -13876.43    -13876.43   -14018.044   -14018.044    273.96202    273.96202    47899.997    47899.997   -570.35763   -570.35763 
   47000   -13880.628   -13880.628   -14020.653   -14020.653    270.88888    270.88888    47857.738    47857.738    296.44298    296.44298 
Loop time of 363.655 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 101.015 hours/ns, 2.750 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    | 362.75     | 362.75     | 362.75     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14296    | 0.14296    | 0.14296    |   0.0 |  0.04
Output  | 0.00017848 | 0.00017848 | 0.00017848 |   0.0 |  0.00
Modify  | 0.66896    | 0.66896    | 0.66896    |   0.0 |  0.18
Other   |            | 0.09696    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      531460.0 ave      531460 max      531460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531460
Ave neighs/atom = 132.86500
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.95814720205, Press = 1.3762822457281
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 = 11 11 11
  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) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -13880.628   -13880.628   -14020.653   -14020.653    270.88888    270.88888    47857.738    47857.738    296.44298    296.44298 
   48000   -13875.593   -13875.593   -14017.496   -14017.496    274.52129    274.52129    47824.969    47824.969    1614.7442    1614.7442 
Loop time of 364.068 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.130 hours/ns, 2.747 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    | 363.16     | 363.16     | 363.16     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14287    | 0.14287    | 0.14287    |   0.0 |  0.04
Output  | 0.00017792 | 0.00017792 | 0.00017792 |   0.0 |  0.00
Modify  | 0.66945    | 0.66945    | 0.66945    |   0.0 |  0.18
Other   |            | 0.09693    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      532066.0 ave      532066 max      532066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532066
Ave neighs/atom = 133.01650
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
47875.6062319807

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0