| Revisión | 8cae309368cc0f56524723509d3a9b1455193f97 (tree) |
|---|---|
| Tiempo | 2021-11-02 01:34:28 |
| Autor |  Mitsuaki Kawamura <kawamitsuaki@gmai...> |
| Commiter | Mitsuaki Kawamura |
Bug fix
README.md (diff)
src/libtetrabz/__init__.py (diff) src/libtetrabz/libtetrabz_common.py (diff) src/libtetrabz/libtetrabz_dbldelta.py (diff) src/libtetrabz/libtetrabz_dblstep.py (diff) src/libtetrabz/libtetrabz_dos.py (diff) src/libtetrabz/libtetrabz_fermigr.py (diff) src/libtetrabz/libtetrabz_occ.py (diff) src/libtetrabz/libtetrabz_polcmplx.py (diff) src/libtetrabz/libtetrabz_polstat.py (diff)| @@ -1,5 +1,16 @@ | ||
| 1 | 1 | # libtetrabz |
| 2 | 2 | |
| 3 | -This is a simple example package. You can use | |
| 4 | -[Github-flavored Markdown](https://guides.github.com/features/mastering-markdown/) | |
| 5 | -to write your content. | |
| 3 | +Libtetrabz is a library which parform efficiently the Brillouin-zone | |
| 4 | +integration in the electronic structure calculation in a solid by | |
| 5 | +using the tetrahedron method. | |
| 6 | + | |
| 7 | +## For citing libtetrabz | |
| 8 | + | |
| 9 | +We would appreciate if you cite the following article in your | |
| 10 | +research with libtetrabz. | |
| 11 | + | |
| 12 | +"Improved tetrahedron method for the Brillouin-zone integration applicable to response functions", | |
| 13 | + | |
| 14 | +M. Kawamura, Y. Gohda, and S. Tsuneyuki, Phys. Rev. B 89, 094515 (2014). | |
| 15 | + | |
| 16 | +https://journals.aps.org/prb/abstract/10.1103/PhysRevB.89.094515 |
| @@ -20,12 +20,12 @@ | ||
| 20 | 20 | # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| 21 | 21 | # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 22 | 22 | # |
| 23 | -from libtetrabz_dos import dos | |
| 24 | -from libtetrabz_dos import intdos | |
| 25 | -from libtetrabz_occ import occ | |
| 26 | -from libtetrabz_occ import fermieng | |
| 27 | -from libtetrabz_polstat import polstat | |
| 28 | -from libtetrabz_fermigr import fermigr | |
| 29 | -from libtetrabz_dbldelta import dbldelta | |
| 30 | -from libtetrabz_dblstep import dblstep | |
| 31 | -from libtetrabz_polcmplx import polcmplx | |
| 23 | +from .libtetrabz_dos import dos | |
| 24 | +from .libtetrabz_dos import intdos | |
| 25 | +from .libtetrabz_occ import occ | |
| 26 | +from .libtetrabz_occ import fermieng | |
| 27 | +from .libtetrabz_polstat import polstat | |
| 28 | +from .libtetrabz_fermigr import fermigr | |
| 29 | +from .libtetrabz_dbldelta import dbldelta | |
| 30 | +from .libtetrabz_dblstep import dblstep | |
| 31 | +from .libtetrabz_polcmplx import polcmplx |
| @@ -132,15 +132,15 @@ def libtetrabz_initialize(ng, bvec): | ||
| 132 | 132 | ikv = numpy.empty([nk*6, 20, 3], dtype=numpy.int_) |
| 133 | 133 | ikv0 = numpy.empty(3, dtype=numpy.int_) |
| 134 | 134 | nt = 0 |
| 135 | - for i3 in range(ng[2]): | |
| 136 | - for i2 in range(ng[1]): | |
| 137 | - for i1 in range(ng[0]): | |
| 135 | + for i2 in range(ng[2]): | |
| 136 | + for i1 in range(ng[1]): | |
| 137 | + for i0 in range(ng[0]): | |
| 138 | 138 | # |
| 139 | 139 | for it in range(6): |
| 140 | 140 | # |
| 141 | 141 | for ii in range(20): |
| 142 | 142 | # |
| 143 | - ikv0[0:3] = numpy.array([i1, i2, i3]) + ivvec[it, ii, 0:3] | |
| 143 | + ikv0[0:3] = [i0, i1, i2] + ivvec[it, ii, 0:3] | |
| 144 | 144 | ikv[nt, ii, 0:3] = ikv0[0:3] % ng[0:3] |
| 145 | 145 | # |
| 146 | 146 | nt += 1 |
| @@ -150,16 +150,16 @@ def libtetrabz_initialize(ng, bvec): | ||
| 150 | 150 | def libtetrabz_tsmall_a1(e): |
| 151 | 151 | """Cut small tetrahedron A1 |
| 152 | 152 | """ |
| 153 | - a = numpy.empty(shape=(4, 4), dtype=numpy.float_) | |
| 154 | - for ii in range(4): | |
| 155 | - a[0:4, ii] = (0.0 - e[ii]) / (e[0:4] - e[ii]) | |
| 153 | + a10 = (0.0 - e[0]) / (e[1] - e[0]) | |
| 154 | + a20 = (0.0 - e[0]) / (e[2] - e[0]) | |
| 155 | + a30 = (0.0 - e[0]) / (e[3] - e[0]) | |
| 156 | 156 | # |
| 157 | - v = a[1, 0] * a[2, 0] * a[3, 0] | |
| 157 | + v = a10 * a20 * a30 | |
| 158 | 158 | # |
| 159 | - tsmall = numpy.array([[1.0, 0.0, 0.0, 0.0], | |
| 160 | - [a[0, 1], a[1, 0], 0.0, 0.0], | |
| 161 | - [a[0, 2], 0.0, a[2, 0], 0.0], | |
| 162 | - [a[0, 3], 0.0, 0.0, a[3, 0]]]) | |
| 159 | + tsmall = numpy.array([[1.0, 0.0, 0.0, 0.0], | |
| 160 | + [1.0 - a10, a10, 0.0, 0.0], | |
| 161 | + [1.0 - a20, 0.0, a20, 0.0], | |
| 162 | + [1.0 - a30, 0.0, 0.0, a30]]) | |
| 163 | 163 | return v, tsmall |
| 164 | 164 | |
| 165 | 165 |
| @@ -171,15 +171,15 @@ def libtetrabz_tsmall_b1(e): | ||
| 171 | 171 | """ |
| 172 | 172 | # |
| 173 | 173 | # |
| 174 | - a = numpy.empty(shape=(4, 4), dtype=numpy.float_) | |
| 175 | - for ii in range(4): | |
| 176 | - a[0:4, ii] = (0.0 - e[ii]) / (e[0:4] - e[ii]) | |
| 174 | + a13 = (0.0 - e[3]) / (e[1] - e[3]) | |
| 175 | + a20 = (0.0 - e[0]) / (e[2] - e[0]) | |
| 176 | + a30 = (0.0 - e[0]) / (e[3] - e[0]) | |
| 177 | 177 | # |
| 178 | - v = a[2, 0] * a[3, 0] * a[1, 3] | |
| 179 | - tsmall = numpy.array([[1.0, 0.0, 0.0, 0.0], | |
| 180 | - [a[0, 2], 0.0, a[2, 0], 0.0], | |
| 181 | - [a[0, 3], 0.0, 0.0, a[3, 0]], | |
| 182 | - [0.0, a[1, 3], 0.0, a[3, 1]]]) | |
| 178 | + v = a20 * a30 * a13 | |
| 179 | + tsmall = numpy.array([[1.0, 0.0, 0.0, 0.0], | |
| 180 | + [1.0 - a20, 0.0, a20, 0.0], | |
| 181 | + [1.0 - a30, 0.0, 0.0, a30], | |
| 182 | + [0.0, a13, 0.0, 1.0 - a13]]) | |
| 183 | 183 | return v, tsmall |
| 184 | 184 | |
| 185 | 185 |
| @@ -189,16 +189,15 @@ def libtetrabz_tsmall_b2(e): | ||
| 189 | 189 | :param e: |
| 190 | 190 | :return: |
| 191 | 191 | """ |
| 192 | - a = numpy.empty(shape=(4, 4), dtype=numpy.float_) | |
| 193 | - for ii in range(4): | |
| 194 | - a[0:4, ii] = (0.0 - e[ii]) / (e[0:4] - e[ii]) | |
| 192 | + a21 = (0.0 - e[1]) / (e[2] - e[1]) | |
| 193 | + a31 = (0.0 - e[1]) / (e[3] - e[1]) | |
| 195 | 194 | # |
| 196 | - v = a[2, 1] * a[3, 1] | |
| 195 | + v = a21 * a31 | |
| 197 | 196 | # |
| 198 | - tsmall = numpy.array([[1.0, 0.0, 0.0, 0.0], | |
| 199 | - [0.0, 1.0, 0.0, 0.0], | |
| 200 | - [0.0, a[1, 2], a[2, 1], 0.0], | |
| 201 | - [0.0, a[1, 3], 0.0, a[3, 1]]]) | |
| 197 | + tsmall = numpy.array([[1.0, 0.0, 0.0, 0.0], | |
| 198 | + [0.0, 1.0, 0.0, 0.0], | |
| 199 | + [0.0, 1.0 - a21, a21, 0.0], | |
| 200 | + [0.0, 1.0 - a31, 0.0, a31]]) | |
| 202 | 201 | return v, tsmall |
| 203 | 202 | |
| 204 | 203 |
| @@ -208,16 +207,16 @@ def libtetrabz_tsmall_b3(e): | ||
| 208 | 207 | :param e: |
| 209 | 208 | :return: |
| 210 | 209 | """ |
| 211 | - a = numpy.empty(shape=(4, 4), dtype=numpy.float_) | |
| 212 | - for ii in range(4): | |
| 213 | - a[0:4, ii] = (0.0 - e[ii]) / (e[0:4] - e[ii]) | |
| 210 | + a12 = (0.0 - e[2]) / (e[1] - e[2]) | |
| 211 | + a20 = (0.0 - e[0]) / (e[2] - e[0]) | |
| 212 | + a31 = (0.0 - e[1]) / (e[3] - e[1]) | |
| 214 | 213 | # |
| 215 | - v = a[1, 2] * a[2, 0] * a[3, 1] | |
| 214 | + v = a12 * a20 * a31 | |
| 216 | 215 | # |
| 217 | - tsmall = numpy.array([[1.0, 0.0, 0.0, 0.0], | |
| 218 | - [a[0, 2], 0.0, a[2, 0], 0.0], | |
| 219 | - [0.0, a[1, 2], a[2, 1], 0.0], | |
| 220 | - [0.0, a[1, 3], 0.0, a[3, 1]]]) | |
| 216 | + tsmall = numpy.array([[1.0, 0.0, 0.0, 0.0], | |
| 217 | + [1.0-a20, 0.0, a20, 0.0], | |
| 218 | + [0.0, a12, 1.0-a12, 0.0], | |
| 219 | + [0.0, 1.0-a31, 0.0, a31]]) | |
| 221 | 220 | return v, tsmall |
| 222 | 221 | |
| 223 | 222 |
| @@ -227,16 +226,14 @@ def libtetrabz_tsmall_c1(e): | ||
| 227 | 226 | :param e: |
| 228 | 227 | :return: |
| 229 | 228 | """ |
| 230 | - a = numpy.empty(shape=(4, 4), dtype=numpy.float_) | |
| 231 | - for ii in range(4): | |
| 232 | - a[0:4, ii] = (0.0 - e[ii]) / (e[0:4] - e[ii]) | |
| 229 | + a32 = (0.0 - e[2]) / (e[3] - e[2]) | |
| 233 | 230 | # |
| 234 | - v = a[3, 2] | |
| 231 | + v = a32 | |
| 235 | 232 | # |
| 236 | - tsmall = numpy.array([[1.0, 0.0, 0.0, 0.0], | |
| 237 | - [0.0, 1.0, 0.0, 0.0], | |
| 238 | - [0.0, 0.0, 1.0, 0.0], | |
| 239 | - [0.0, 0.0, a[2, 3], a[3, 2]]]) | |
| 233 | + tsmall = numpy.array([[1.0, 0.0, 0.0, 0.0], | |
| 234 | + [0.0, 1.0, 0.0, 0.0], | |
| 235 | + [0.0, 0.0, 1.0, 0.0], | |
| 236 | + [0.0, 0.0, 1.0 - a32, a32]]) | |
| 240 | 237 | return v, tsmall |
| 241 | 238 | |
| 242 | 239 |
| @@ -246,16 +243,15 @@ def libtetrabz_tsmall_c2(e): | ||
| 246 | 243 | :param e: |
| 247 | 244 | :return: |
| 248 | 245 | """ |
| 249 | - a = numpy.empty(shape=(4, 4), dtype=numpy.float_) | |
| 250 | - for ii in range(4): | |
| 251 | - a[0:4, ii] = (0.0 - e[ii]) / (e[0:4] - e[ii]) | |
| 246 | + a23 = (0.0 - e[3]) / (e[2] - e[3]) | |
| 247 | + a31 = (0.0 - e[1]) / (e[3] - e[1]) | |
| 252 | 248 | # |
| 253 | - v = a[2, 3] * a[3, 1] | |
| 249 | + v = a23 * a31 | |
| 254 | 250 | # |
| 255 | - tsmall = numpy.array([[1.0, 0.0, 0.0, 0.0], | |
| 256 | - [0.0, 1.0, 0.0, 0.0], | |
| 257 | - [0.0, a[1, 3], 0.0, a[3, 1]], | |
| 258 | - [0.0, 0.0, a[2, 3], a[3, 2]]]) | |
| 251 | + tsmall = numpy.array([[1.0, 0.0, 0.0, 0.0], | |
| 252 | + [0.0, 1.0, 0.0, 0.0], | |
| 253 | + [0.0, 1.0 - a31, 0.0, a31], | |
| 254 | + [0.0, 0.0, a23, 1.0 - a23]]) | |
| 259 | 255 | return v, tsmall |
| 260 | 256 | |
| 261 | 257 |
| @@ -265,16 +261,16 @@ def libtetrabz_tsmall_c3(e): | ||
| 265 | 261 | :param e: |
| 266 | 262 | :return: |
| 267 | 263 | """ |
| 268 | - a = numpy.empty(shape=(4, 4), dtype=numpy.float_) | |
| 269 | - for ii in range(4): | |
| 270 | - a[0:4, ii] = (0.0 - e[ii]) / (e[0:4] - e[ii]) | |
| 264 | + a23 = (0.0 - e[3]) / (e[2] - e[3]) | |
| 265 | + a13 = (0.0 - e[3]) / (e[1] - e[3]) | |
| 266 | + a30 = (0.0 - e[0]) / (e[3] - e[0]) | |
| 271 | 267 | # |
| 272 | - v = a[2, 3] * a[1, 3] * a[3, 0] | |
| 268 | + v = a23 * a13 * a30 | |
| 273 | 269 | # |
| 274 | - tsmall = numpy.array([[1.0, 0.0, 0.0, 0.0], | |
| 275 | - [a[0, 3], 0.0, 0.0, a[3, 0]], | |
| 276 | - [0.0, a[1, 3], 0.0, a[3, 1]], | |
| 277 | - [0.0, 0.0, a[2, 3], a[3, 2]]]) | |
| 270 | + tsmall = numpy.array([[1.0, 0.0, 0.0, 0.0], | |
| 271 | + [1.0 - a30, 0.0, 0.0, a30], | |
| 272 | + [0.0, a13, 0.0, 1.0 - a13], | |
| 273 | + [0.0, 0.0, a23, 1.0 - a23]]) | |
| 278 | 274 | return v, tsmall |
| 279 | 275 | |
| 280 | 276 |
| @@ -284,16 +280,16 @@ def libtetrabz_triangle_a1(e): | ||
| 284 | 280 | :param e: |
| 285 | 281 | :return: |
| 286 | 282 | """ |
| 287 | - a = numpy.empty(shape=(4, 4), dtype=numpy.float_) | |
| 288 | - for ii in range(4): | |
| 289 | - a[0:4, ii] = (0.0 - e[ii]) / (e[0:4] - e[ii]) | |
| 283 | + a10 = (0.0 - e[0]) / (e[1] - e[0]) | |
| 284 | + a20 = (0.0 - e[0]) / (e[2] - e[0]) | |
| 285 | + a30 = (0.0 - e[0]) / (e[3] - e[0]) | |
| 290 | 286 | # |
| 291 | - # v = 3.0 * a[1,0] * a[2,0] * a[3,0] / (0.0 - e(1)) | |
| 292 | - v = 3.0 * a[1, 0] * a[2, 0] / (e(4) - e(1)) | |
| 287 | + # v = 3.0 * a[1,0] * a[2,0] * a[3,0] / (0.0 - e[0]) | |
| 288 | + v = 3.0 * a10 * a20 / (e[3] - e[0]) | |
| 293 | 289 | # |
| 294 | - tsmall = numpy.array([[a[0, 1], a[1, 0], 0.0, 0.0], | |
| 295 | - [a[0, 2], 0.0, a[2, 0], 0.0], | |
| 296 | - [a[0, 3], 0.0, 0.0, a[3, 0]]]) | |
| 290 | + tsmall = numpy.array([[1.0 - a10, a10, 0.0, 0.0], | |
| 291 | + [1.0 - a20, 0.0, a20, 0.0], | |
| 292 | + [1.0 - a30, 0.0, 0.0, a30]]) | |
| 297 | 293 | return v, tsmall |
| 298 | 294 | |
| 299 | 295 |
| @@ -303,16 +299,16 @@ def libtetrabz_triangle_b1(e): | ||
| 303 | 299 | :param e: |
| 304 | 300 | :return: |
| 305 | 301 | """ |
| 306 | - a = numpy.empty(shape=(4, 4), dtype=numpy.float_) | |
| 307 | - for ii in range(4): | |
| 308 | - a[0:4, ii] = (0.0 - e[ii]) / (e[0:4] - e[ii]) | |
| 302 | + a30 = (0.0 - e[0]) / (e[3] - e[0]) | |
| 303 | + a13 = (0.0 - e[3]) / (e[1] - e[3]) | |
| 304 | + a20 = (0.0 - e[0]) / (e[2] - e[0]) | |
| 309 | 305 | # |
| 310 | - # v = 3.0 * a[2,0] * a[3,0] * a[1,3] / (0.0 - e(1)) | |
| 311 | - v = 3.0 * a[3, 0] * a[1, 3] / (e(3) - e(1)) | |
| 306 | + # v = 3.0 * a[2,0] * a[3,0] * a[1,3] / (0.0 - e[0]) | |
| 307 | + v = 3.0 * a30 * a13 / (e[2] - e[0]) | |
| 312 | 308 | # |
| 313 | - tsmall = numpy.array([[a[0, 2], 0.0, a[2, 0], 0.0], | |
| 314 | - [a[0, 3], 0.0, 0.0, a[3, 0]], | |
| 315 | - [0.0, a[1, 3], 0.0, a[3, 1]]]) | |
| 309 | + tsmall = numpy.array([[1.0 - a20, 0.0, a20, 0.0], | |
| 310 | + [1.0 - a30, 0.0, 0.0, a30], | |
| 311 | + [0.0, a13, 0.0, 1.0 - a13]]) | |
| 316 | 312 | return v, tsmall |
| 317 | 313 | |
| 318 | 314 |
| @@ -321,16 +317,16 @@ def libtetrabz_triangle_b2(e): | ||
| 321 | 317 | :param e: |
| 322 | 318 | :return: |
| 323 | 319 | """ |
| 324 | - a = numpy.empty(shape=(4, 4), dtype=numpy.float_) | |
| 325 | - for ii in range(4): | |
| 326 | - a[0:4, ii] = (0.0 - e[ii]) / (e[0:4] - e[ii]) | |
| 320 | + a12 = (0.0 - e[2]) / (e[1] - e[2]) | |
| 321 | + a31 = (0.0 - e[1]) / (e[3] - e[1]) | |
| 322 | + a20 = (0.0 - e[0]) / (e[2] - e[0]) | |
| 327 | 323 | # |
| 328 | - # v = 3.0 * a[1,2] * a[2,0] * a[3,1] / (0.0 - e(1)) | |
| 329 | - v = 3.0 * a[1, 2] * a[3, 1] / (e[2] - e[0]) | |
| 324 | + # v = 3.0 * a[1,2] * a[2,0] * a[3,1] / (0.0 - e[0]) | |
| 325 | + v = 3.0 * a12 * a31 / (e[2] - e[0]) | |
| 330 | 326 | # |
| 331 | - tsmall = numpy.array([[a[0, 2], 0.0, a[2, 0], 0.0], | |
| 332 | - [0.0, a[1, 2], a[2, 1], 0.0], | |
| 333 | - [0.0, a[1, 3], 0.0, a[3, 1]]]) | |
| 327 | + tsmall = numpy.array([[1.0 - a20, 0.0, a20, 0.0], | |
| 328 | + [0.0, a12, 1.0 - a12, 0.0], | |
| 329 | + [0.0, 1.0 - a31, 0.0, a31]]) | |
| 334 | 330 | return v, tsmall |
| 335 | 331 | |
| 336 | 332 |
| @@ -339,14 +335,14 @@ def libtetrabz_triangle_c1(e): | ||
| 339 | 335 | :param e: |
| 340 | 336 | :return: |
| 341 | 337 | """ |
| 342 | - a = numpy.empty(shape=(4, 4), dtype=numpy.float_) | |
| 343 | - for ii in range(4): | |
| 344 | - a[0:4, ii] = (0.0 - e[ii]) / (e[0:4] - e[ii]) | |
| 338 | + a03 = (0.0 - e[3]) / (e[0] - e[3]) | |
| 339 | + a13 = (0.0 - e[3]) / (e[1] - e[3]) | |
| 340 | + a23 = (0.0 - e[3]) / (e[2] - e[3]) | |
| 345 | 341 | # |
| 346 | - # v = 3.0 * a[0,3] * a[1,3] * a[2,3] / (e(4) - 0.0) | |
| 347 | - v = 3.0 * a[0, 3] * a[1, 3] / (e[3] - e[2]) | |
| 342 | + # v = 3.0 * a[0,3] * a[1,3] * a[2,3] / (e[3] - 0.0) | |
| 343 | + v = 3.0 * a03 * a13 / (e[3] - e[2]) | |
| 348 | 344 | # |
| 349 | - tsmall = numpy.array([[a[0, 3], 0.0, 0.0, a[3, 0]], | |
| 350 | - [0.0, a[1, 3], 0.0, a[3, 1]], | |
| 351 | - [0.0, 0.0, a[2, 3], a[3, 2]]]) | |
| 345 | + tsmall = numpy.array([[a03, 0.0, 0.0, 1.0 - a03], | |
| 346 | + [0.0, a13, 0.0, 1.0 - a13], | |
| 347 | + [0.0, 0.0, a23, 1.0 - a23]]) | |
| 352 | 348 | return v, tsmall |
| @@ -21,7 +21,7 @@ | ||
| 21 | 21 | # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 22 | 22 | # |
| 23 | 23 | import numpy |
| 24 | -import libtetrabz_common | |
| 24 | +from . import libtetrabz_common | |
| 25 | 25 | |
| 26 | 26 | |
| 27 | 27 | def dbldelta(bvec, eig1, eig2): |
| @@ -37,23 +37,22 @@ def dbldelta(bvec, eig1, eig2): | ||
| 37 | 37 | nk = ng.prod(0) |
| 38 | 38 | nb = eig1.shape[3] |
| 39 | 39 | wlsm, ikv = libtetrabz_common.libtetrabz_initialize(ng, bvec) |
| 40 | - | |
| 40 | + # | |
| 41 | 41 | wght = numpy.zeros([ng[0], ng[1], ng[2], nb, nb], dtype=numpy.float_) |
| 42 | - | |
| 43 | - eig1t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 44 | - eig2t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 45 | - | |
| 42 | + # | |
| 46 | 43 | for it in range(6 * nk): |
| 47 | 44 | # |
| 45 | + eig1t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 46 | + eig2t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 48 | 47 | for ii in range(20): |
| 49 | 48 | eig1t[ii, 0:nb] = eig1[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb] |
| 50 | 49 | eig2t[ii, 0:nb] = eig2[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb] |
| 51 | - | |
| 52 | 50 | ei1 = wlsm.dot(eig1t) |
| 53 | 51 | ej1 = wlsm.dot(eig2t) |
| 52 | + # | |
| 53 | + w1 = numpy.zeros([nb, nb, 4], dtype=numpy.float_) | |
| 54 | 54 | for ib in range(nb): |
| 55 | 55 | # |
| 56 | - w1 = numpy.zeros([nb, 4], dtype=numpy.float_) | |
| 57 | 56 | e = ei1[0:4, ib] |
| 58 | 57 | indx = e.argsort(0) |
| 59 | 58 | e.sort(0) |
| @@ -66,7 +65,7 @@ def dbldelta(bvec, eig1, eig2): | ||
| 66 | 65 | # |
| 67 | 66 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 68 | 67 | w2 = libtetrabz_dbldelta2(ej2) |
| 69 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 68 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 70 | 69 | # |
| 71 | 70 | elif e[1] < 0.0 <= e[2]: |
| 72 | 71 | # |
| @@ -75,14 +74,14 @@ def dbldelta(bvec, eig1, eig2): | ||
| 75 | 74 | if v > thr: |
| 76 | 75 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 77 | 76 | w2 = libtetrabz_dbldelta2(ej2) |
| 78 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 77 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 79 | 78 | # |
| 80 | 79 | v, tsmall = libtetrabz_common.libtetrabz_triangle_b2(e) |
| 81 | 80 | # |
| 82 | 81 | if v > thr: |
| 83 | 82 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 84 | 83 | w2 = libtetrabz_dbldelta2(ej2) |
| 85 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 84 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 86 | 85 | # |
| 87 | 86 | elif e[2] < 0.0 < e[3]: |
| 88 | 87 | # |
| @@ -91,15 +90,16 @@ def dbldelta(bvec, eig1, eig2): | ||
| 91 | 90 | if v > thr: |
| 92 | 91 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 93 | 92 | w2 = libtetrabz_dbldelta2(ej2) |
| 94 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 93 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 95 | 94 | # |
| 96 | 95 | else: |
| 97 | 96 | continue |
| 98 | - # | |
| 99 | - for ii in range(20): | |
| 100 | - wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], ib, 0:nb] += w1.dot(wlsm) | |
| 97 | + # | |
| 98 | + for ii in range(20): | |
| 99 | + wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb, 0:nb] += w1.dot(wlsm[:, ii]) | |
| 101 | 100 | # |
| 102 | 101 | wght[0:ng[0], 0:ng[1], 0:ng[2], 0:nb, 0:nb] /= (6.0 * nk) |
| 102 | + return wght | |
| 103 | 103 | |
| 104 | 104 | |
| 105 | 105 | def libtetrabz_dbldelta2(ej): |
| @@ -21,7 +21,7 @@ | ||
| 21 | 21 | # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 22 | 22 | # |
| 23 | 23 | import numpy |
| 24 | -import libtetrabz_common | |
| 24 | +from . import libtetrabz_common | |
| 25 | 25 | |
| 26 | 26 | |
| 27 | 27 | def dblstep(bvec, eig1, eig2): |
| @@ -39,23 +39,21 @@ def dblstep(bvec, eig1, eig2): | ||
| 39 | 39 | |
| 40 | 40 | wght = numpy.zeros([ng[0], ng[1], ng[2], nb, nb], dtype=numpy.float_) |
| 41 | 41 | |
| 42 | - eig1t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 43 | - eig2t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 44 | - | |
| 45 | 42 | thr = 1.0e-8 |
| 46 | 43 | # |
| 47 | 44 | for it in range(6 * nk): |
| 48 | 45 | # |
| 46 | + eig1t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 47 | + eig2t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 49 | 48 | for ii in range(20): |
| 50 | 49 | eig1t[ii, 0:nb] = eig1[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb] |
| 51 | 50 | eig2t[ii, 0:nb] = eig2[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb] |
| 52 | - | |
| 53 | 51 | ei1 = wlsm.dot(eig1t) |
| 54 | 52 | ej1 = wlsm.dot(eig2t) |
| 55 | 53 | # |
| 54 | + w1 = numpy.zeros([nb, nb, 4], dtype=numpy.float_) | |
| 56 | 55 | for ib in range(nb): |
| 57 | 56 | # |
| 58 | - w1 = numpy.zeros([nb, 4], dtype=numpy.float_) | |
| 59 | 57 | e = ei1[0:4, ib] |
| 60 | 58 | indx = e.argsort(0) |
| 61 | 59 | e.sort(0) |
| @@ -65,84 +63,76 @@ def dblstep(bvec, eig1, eig2): | ||
| 65 | 63 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_a1(e) |
| 66 | 64 | # |
| 67 | 65 | if v > thr: |
| 68 | - # | |
| 69 | 66 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 70 | 67 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 71 | 68 | w2 = libtetrabz_dblstep2(ei2, ej2) |
| 72 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 69 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 73 | 70 | # |
| 74 | 71 | elif e(2) <= 0.0 < e(3): |
| 75 | 72 | # |
| 76 | 73 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b1(e) |
| 77 | 74 | # |
| 78 | 75 | if v > thr: |
| 79 | - # | |
| 80 | 76 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 81 | 77 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 82 | 78 | w2 = libtetrabz_dblstep2(ei2, ej2) |
| 83 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 79 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 84 | 80 | # |
| 85 | 81 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b2(e) |
| 86 | 82 | # |
| 87 | 83 | if v > thr: |
| 88 | - # | |
| 89 | 84 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 90 | 85 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 91 | 86 | w2 = libtetrabz_dblstep2(ei2, ej2) |
| 92 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 87 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 93 | 88 | # |
| 94 | 89 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b3(e) |
| 95 | 90 | # |
| 96 | 91 | if v > thr: |
| 97 | - # | |
| 98 | 92 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 99 | 93 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 100 | 94 | w2 = libtetrabz_dblstep2(ei2, ej2) |
| 101 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 95 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 102 | 96 | # |
| 103 | 97 | elif e(3) <= 0.0 < e(4): |
| 104 | 98 | # |
| 105 | 99 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c1(e) |
| 106 | 100 | # |
| 107 | 101 | if v > thr: |
| 108 | - # | |
| 109 | 102 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 110 | 103 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 111 | 104 | w2 = libtetrabz_dblstep2(ei2, ej2) |
| 112 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 105 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 113 | 106 | # |
| 114 | 107 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c2(e) |
| 115 | 108 | # |
| 116 | 109 | if v > thr: |
| 117 | - # | |
| 118 | 110 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 119 | 111 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 120 | 112 | w2 = libtetrabz_dblstep2(ei2, ej2) |
| 121 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 113 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 122 | 114 | # |
| 123 | 115 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c3(e) |
| 124 | 116 | # |
| 125 | 117 | if v > thr: |
| 126 | - # | |
| 127 | 118 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 128 | 119 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 129 | 120 | w2 = libtetrabz_dblstep2(ei2, ej2) |
| 130 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 121 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 131 | 122 | # |
| 132 | 123 | elif e(4) <= 0.0: |
| 133 | - # | |
| 134 | 124 | ei2 = ei1[0:4, ib] |
| 135 | 125 | ej2 = ej1[0:4, 0:nb] |
| 136 | 126 | w2 = libtetrabz_dblstep2(ei2, ej2) |
| 137 | - w1[0:nb, 0:4] += w2[0:nb, 0:4] | |
| 138 | - # | |
| 127 | + w1[ib, 0:nb, 0:4] += w2[0:nb, 0:4] | |
| 139 | 128 | else: |
| 140 | 129 | continue |
| 141 | 130 | # |
| 142 | - for ii in range(20): | |
| 143 | - wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], ib, 0:nb] += w1.dot(wlsm) | |
| 144 | - | |
| 131 | + for ii in range(20): | |
| 132 | + wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb, 0:nb] += w1.dot(wlsm[:, ii]) | |
| 133 | + # | |
| 145 | 134 | wght[0:ng[0], 0:ng[1], 0:ng[2], 0:nb, 0:nb] /= (6.0 * nk) |
| 135 | + return wght | |
| 146 | 136 | |
| 147 | 137 | |
| 148 | 138 | def libtetrabz_dblstep2(ei1, ej1): |
| @@ -21,16 +21,16 @@ | ||
| 21 | 21 | # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 22 | 22 | # |
| 23 | 23 | import numpy |
| 24 | -import libtetrabz_common | |
| 24 | +from . import libtetrabz_common | |
| 25 | 25 | |
| 26 | 26 | |
| 27 | 27 | def dos(bvec, eig, e0): |
| 28 | 28 | """ |
| 29 | 29 | Compute Dos : Delta(E - E1) |
| 30 | - :param bvec: | |
| 31 | - :param eig: | |
| 32 | - :param e0: | |
| 33 | - :return: | |
| 30 | + :param ndarray([3, 3], float) bvec: Reciprocal-lattice vectors | |
| 31 | + :param ndarray([ng0, ng1, ng2, nb], float) eig: Energy eigenvalue | |
| 32 | + :param ndarray(ne, float) e0: Energy grid | |
| 33 | + :return ndarray([ng0, ng1, ng2, nb, ne], float) wght: Weight | |
| 34 | 34 | """ |
| 35 | 35 | |
| 36 | 36 | ng = numpy.array(eig.shape[0:3]) |
| @@ -41,47 +41,49 @@ def dos(bvec, eig, e0): | ||
| 41 | 41 | |
| 42 | 42 | wght = numpy.zeros([ng[0], ng[1], ng[2], nb, ne], dtype=numpy.float_) |
| 43 | 43 | |
| 44 | - eigt = numpy.empty([20, nb], dtype=numpy.float_) | |
| 45 | 44 | for it in range(6*nk): |
| 46 | 45 | # |
| 46 | + eigt = numpy.empty([20, nb], dtype=numpy.float_) | |
| 47 | 47 | for ii in range(20): |
| 48 | 48 | eigt[ii, 0:nb] = eig[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb] |
| 49 | - | |
| 50 | 49 | ei1 = wlsm.dot(eigt) |
| 51 | 50 | # |
| 51 | + w1 = numpy.zeros([nb, ne, 4], dtype=numpy.float_) | |
| 52 | + # | |
| 52 | 53 | for ib in range(nb): |
| 53 | 54 | # |
| 54 | - w1 = numpy.zeros([ne, 4], dtype=numpy.float_) | |
| 55 | 55 | e = ei1[0:4, ib] |
| 56 | 56 | indx = e.argsort(0) |
| 57 | - e.sort(0) | |
| 57 | + e = e[indx[0:4]] | |
| 58 | 58 | # |
| 59 | 59 | for ie in range(ne): |
| 60 | 60 | # |
| 61 | 61 | if e[0] < e0[ie] <= e[1] or e[0] <= e0[ie] < e[1]: |
| 62 | 62 | # |
| 63 | 63 | v, tsmall = libtetrabz_common.libtetrabz_triangle_a1(e[0:4] - e0[ie]) |
| 64 | - w1[ie, indx[0:4]] += v * tsmall.sum(0) / 3.0 | |
| 64 | + w1[ib, ie, indx[0:4]] += v * tsmall.sum(0) / 3.0 | |
| 65 | 65 | # |
| 66 | 66 | elif e[1] < e0[ie] <= e[2] or e[1] <= e0[ie] < e[2]: |
| 67 | 67 | # |
| 68 | 68 | v, tsmall = libtetrabz_common.libtetrabz_triangle_b1(e[0:4] - e0[ie]) |
| 69 | - w1[ie, indx[0:4]] += v * tsmall.sum(0) / 3.0 | |
| 69 | + w1[ib, ie, indx[0:4]] += v * tsmall.sum(0) / 3.0 | |
| 70 | 70 | # |
| 71 | 71 | v, tsmall = libtetrabz_common.libtetrabz_triangle_b2(e[0:4] - e0[ie]) |
| 72 | - w1[ie, indx[0:4]] += v * tsmall.sum(0) / 3.0 | |
| 72 | + w1[ib, ie, indx[0:4]] += v * tsmall.sum(0) / 3.0 | |
| 73 | 73 | # |
| 74 | 74 | elif e[2] < e0[ie] <= e[3] or e[2] <= e0[ie] < e[3]: |
| 75 | 75 | # |
| 76 | 76 | v, tsmall = libtetrabz_common.libtetrabz_triangle_c1(e[0:4] - e0[ie]) |
| 77 | - w1[ie, indx[0:4]] += v * tsmall.sum(0) / 3.0 | |
| 77 | + w1[ib, ie, indx[0:4]] += v * tsmall.sum(0) / 3.0 | |
| 78 | 78 | # |
| 79 | 79 | else: |
| 80 | 80 | continue |
| 81 | 81 | # |
| 82 | - for ii in range(20): | |
| 83 | - wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], ib, 0:ne] += w1.dot(wlsm) | |
| 84 | - # | |
| 82 | + # | |
| 83 | + # | |
| 84 | + for ii in range(20): | |
| 85 | + wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb, 0:ne] += w1.dot(wlsm[:, ii]) | |
| 86 | + # | |
| 85 | 87 | # |
| 86 | 88 | wght[0:ng[0], 0:ng[1], 0:ng[2], 0:nb, 0:ne] /= (6.0 * nk) |
| 87 | 89 | return wght |
| @@ -90,31 +92,30 @@ def dos(bvec, eig, e0): | ||
| 90 | 92 | def intdos(bvec, eig, e0): |
| 91 | 93 | """ |
| 92 | 94 | Compute integrated Dos : theta(E - E1) |
| 93 | - :param bvec: | |
| 94 | - :param eig: | |
| 95 | - :param e0: | |
| 96 | - :return: | |
| 95 | + :param ndarray([3, 3], float) bvec: Reciprocal-lattice vectors | |
| 96 | + :param ndarray([ng0, ng1, ng2, nb], float) eig: Energy eigenvalue | |
| 97 | + :param ndarray(ne, float) e0: Energy grid | |
| 98 | + :return ndarray([ng0, ng1, ng2, nb, ne], float) wght: Weight | |
| 97 | 99 | """ |
| 98 | 100 | ng = numpy.array(eig.shape[0:3]) |
| 99 | 101 | nk = ng.prod(0) |
| 100 | 102 | nb = eig.shape[3] |
| 101 | 103 | ne = e0.shape[0] |
| 102 | 104 | wlsm, ikv = libtetrabz_common.libtetrabz_initialize(ng, bvec) |
| 103 | - | |
| 104 | 105 | # |
| 105 | 106 | wght = numpy.zeros([ng[0], ng[1], ng[2], nb, ne], dtype=numpy.float_) |
| 106 | 107 | # |
| 107 | - eigt = numpy.empty([20, nb], dtype=numpy.float_) | |
| 108 | 108 | for it in range(6*nk): |
| 109 | 109 | # |
| 110 | + eigt = numpy.empty([20, nb], dtype=numpy.float_) | |
| 110 | 111 | for ii in range(20): |
| 111 | 112 | eigt[ii, 0:nb] = eig[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb] |
| 112 | - | |
| 113 | 113 | ei1 = wlsm.dot(eigt) |
| 114 | 114 | # |
| 115 | + w1 = numpy.zeros([nb, ne, 4], dtype=numpy.float_) | |
| 116 | + # | |
| 115 | 117 | for ib in range(nb): |
| 116 | 118 | # |
| 117 | - w1 = numpy.zeros([ne, 4], dtype=numpy.float_) | |
| 118 | 119 | e = ei1[0:4, ib] |
| 119 | 120 | indx = e.argsort(0) |
| 120 | 121 | e.sort(0) |
| @@ -124,40 +125,39 @@ def intdos(bvec, eig, e0): | ||
| 124 | 125 | if e[0] <= e0[ie] < e[1] or e[0] < e0[ie] <= e[1]: |
| 125 | 126 | # |
| 126 | 127 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_a1(e - e0[ie]) |
| 127 | - w1[ie, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 128 | + w1[ib, ie, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 128 | 129 | # |
| 129 | 130 | elif e[1] <= e0[ie] < e[2] or e[1] < e0[ie] <= e[2]: |
| 130 | 131 | # |
| 131 | 132 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b1(e - e0[ie]) |
| 132 | - w1[ie, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 133 | + w1[ib, ie, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 133 | 134 | # |
| 134 | 135 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b2(e - e0[ie]) |
| 135 | - w1[ie, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 136 | + w1[ib, ie, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 136 | 137 | # |
| 137 | 138 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b3(e - e0[ie]) |
| 138 | - w1[ie, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 139 | - # | |
| 139 | + w1[ib, ie, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 140 | + # | |
| 140 | 141 | elif e[2] <= e0[ie] < e[3] or e[2] < e0[ie] .AND. e0[ie] <= e[3]: |
| 141 | 142 | # |
| 142 | 143 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c1(e - e0[ie]) |
| 143 | - w1[ie, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 144 | + w1[ib, ie, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 144 | 145 | # |
| 145 | 146 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c2(e - e0[ie]) |
| 146 | - w1[ie, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 147 | + w1[ib, ie, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 147 | 148 | # |
| 148 | 149 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c3(e - e0[ie]) |
| 149 | - w1[ie, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 150 | - # | |
| 151 | - elif e[3] <= e0(ie): | |
| 152 | - # | |
| 153 | - w1[ie, 0:4] = 0.25 | |
| 150 | + w1[ib, ie, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 154 | 151 | # |
| 152 | + elif e[3] <= e0(ie): | |
| 153 | + w1[ib, ie, 0:4] = 0.25 | |
| 155 | 154 | else: |
| 156 | - # | |
| 157 | 155 | continue |
| 158 | 156 | # |
| 159 | - for ii in range(20): | |
| 160 | - wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], ib, 0:ne] += w1.dot(wlsm) | |
| 161 | - | |
| 157 | + # | |
| 158 | + # | |
| 159 | + for ii in range(20): | |
| 160 | + wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb, 0:ne] += w1.dot(wlsm[:, ii]) | |
| 161 | + # | |
| 162 | 162 | wght[0:ng[0], 0:ng[1], 0:ng[2], 0:nb, 0:ne] /= (6.0 * nk) |
| 163 | 163 | return wght |
| @@ -21,7 +21,7 @@ | ||
| 21 | 21 | # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 22 | 22 | # |
| 23 | 23 | import numpy |
| 24 | -import libtetrabz_common | |
| 24 | +from . import libtetrabz_common | |
| 25 | 25 | |
| 26 | 26 | |
| 27 | 27 | def fermigr(bvec, eig1, eig2, e0): |
| @@ -41,22 +41,21 @@ def fermigr(bvec, eig1, eig2, e0): | ||
| 41 | 41 | |
| 42 | 42 | wght = numpy.zeros([ng[0], ng[1], ng[2], nb, nb, ne], dtype=numpy.float_) |
| 43 | 43 | |
| 44 | - eig1t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 45 | - eig2t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 46 | 44 | thr = 1.0e-10 |
| 47 | 45 | # |
| 48 | 46 | for it in range(6 * nk): |
| 49 | 47 | # |
| 48 | + eig1t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 49 | + eig2t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 50 | 50 | for ii in range(20): |
| 51 | 51 | eig1t[ii, 0:nb] = eig1[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb] |
| 52 | 52 | eig2t[ii, 0:nb] = eig2[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb] |
| 53 | - | |
| 54 | 53 | ei1 = wlsm.dot(eig1t) |
| 55 | 54 | ej1 = wlsm.dot(eig2t) |
| 56 | 55 | # |
| 56 | + w1 = numpy.zeros([nb, nb, ne, 4], dtype=numpy.float_) | |
| 57 | 57 | for ib in range(nb): |
| 58 | 58 | # |
| 59 | - w1 = numpy.zeros([nb, 4], dtype=numpy.float_) | |
| 60 | 59 | e = ei1[0:4, ib] |
| 61 | 60 | indx = e.argsort(0) |
| 62 | 61 | e.sort(0) |
| @@ -70,7 +69,7 @@ def fermigr(bvec, eig1, eig2, e0): | ||
| 70 | 69 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 71 | 70 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 72 | 71 | w2 = libtetrabz_fermigr2(e0, ei2, ej2) |
| 73 | - w1[0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 72 | + w1[ib, 0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 74 | 73 | # |
| 75 | 74 | elif e[1] <= 0.0 < e[2]: |
| 76 | 75 | # |
| @@ -81,7 +80,7 @@ def fermigr(bvec, eig1, eig2, e0): | ||
| 81 | 80 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 82 | 81 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 83 | 82 | w2 = libtetrabz_fermigr2(e0, ei2, ej2) |
| 84 | - w1[0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 83 | + w1[ib, 0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 85 | 84 | # |
| 86 | 85 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b2(e) |
| 87 | 86 | # |
| @@ -90,7 +89,7 @@ def fermigr(bvec, eig1, eig2, e0): | ||
| 90 | 89 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 91 | 90 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 92 | 91 | w2 = libtetrabz_fermigr2(e0, ei2, ej2) |
| 93 | - w1[0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 92 | + w1[ib, 0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 94 | 93 | # |
| 95 | 94 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b3(e) |
| 96 | 95 | # |
| @@ -99,7 +98,7 @@ def fermigr(bvec, eig1, eig2, e0): | ||
| 99 | 98 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 100 | 99 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 101 | 100 | w2 = libtetrabz_fermigr2(e0, ei2, ej2) |
| 102 | - w1[0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 101 | + w1[ib, 0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 103 | 102 | # |
| 104 | 103 | elif e[2] <= 0.0 < e[3]: |
| 105 | 104 | # |
| @@ -110,7 +109,7 @@ def fermigr(bvec, eig1, eig2, e0): | ||
| 110 | 109 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 111 | 110 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 112 | 111 | w2 = libtetrabz_fermigr2(e0, ei2, ej2) |
| 113 | - w1[0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 112 | + w1[ib, 0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 114 | 113 | # |
| 115 | 114 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c2(e) |
| 116 | 115 | # |
| @@ -119,7 +118,7 @@ def fermigr(bvec, eig1, eig2, e0): | ||
| 119 | 118 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 120 | 119 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 121 | 120 | w2 = libtetrabz_fermigr2(e0, ei2, ej2) |
| 122 | - w1[0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 121 | + w1[ib, 0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 123 | 122 | # |
| 124 | 123 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c3(e) |
| 125 | 124 | # |
| @@ -128,22 +127,23 @@ def fermigr(bvec, eig1, eig2, e0): | ||
| 128 | 127 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 129 | 128 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 130 | 129 | w2 = libtetrabz_fermigr2(e0, ei2, ej2) |
| 131 | - w1[0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 130 | + w1[ib, 0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 132 | 131 | # |
| 133 | 132 | elif e[3] <= 0.0: |
| 134 | 133 | # |
| 135 | 134 | ei2 = ei1[0:4, ib] |
| 136 | 135 | ej2 = ej1[0:4, 0:nb] |
| 137 | 136 | w2 = libtetrabz_fermigr2(e0, ei2, ej2) |
| 138 | - w1[0:nb, 0:ne, 0:4] += w2[0:nb, 0:ne, 0:4] | |
| 137 | + w1[ib, 0:nb, 0:ne, 0:4] += w2[0:nb, 0:ne, 0:4] | |
| 139 | 138 | # |
| 140 | 139 | else: |
| 141 | 140 | continue |
| 142 | 141 | # |
| 143 | - for ii in range(20): | |
| 144 | - wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], ib, 0:nb, 0:ne] += w1.dot(wlsm) | |
| 145 | - # | |
| 142 | + for ii in range(20): | |
| 143 | + wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb, 0:nb, 0:ne] += w1.dot(wlsm[:, ii]) | |
| 144 | + # | |
| 146 | 145 | wght[0:ng[0], 0:ng[1], 0:ng[2], 0:nb, 0:nb, 0:ne] /= (6.0 * nk) |
| 146 | + return wght | |
| 147 | 147 | |
| 148 | 148 | |
| 149 | 149 | def libtetrabz_fermigr2(e0, ei1, ej1): |
| @@ -21,15 +21,15 @@ | ||
| 21 | 21 | # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 22 | 22 | # |
| 23 | 23 | import numpy |
| 24 | -import libtetrabz_common | |
| 24 | +from . import libtetrabz_common | |
| 25 | 25 | |
| 26 | 26 | |
| 27 | 27 | def fermieng(bvec, eig, nelec): |
| 28 | 28 | """ |
| 29 | 29 | Calculate Fermi energy |
| 30 | - :param bvec: | |
| 31 | - :param eig: | |
| 32 | - :param nelec: | |
| 30 | + :param ndarray([3, 3], float) bvec: Reciprocal-lattice vectors | |
| 31 | + :param ndarray([ng0, ng1, ng2, nb], float) eig: Energy eigenvalue | |
| 32 | + :param float nelec: | |
| 33 | 33 | :return: |
| 34 | 34 | """ |
| 35 | 35 | # |
| @@ -52,8 +52,8 @@ def fermieng(bvec, eig, nelec): | ||
| 52 | 52 | # |
| 53 | 53 | # convergence check |
| 54 | 54 | # |
| 55 | - if sumkmid - nelec < eps: | |
| 56 | - return ef, wght | |
| 55 | + if abs(sumkmid - nelec) < eps: | |
| 56 | + return ef, wght, iteration | |
| 57 | 57 | elif sumkmid < nelec: |
| 58 | 58 | elw = ef |
| 59 | 59 | else: |
| @@ -62,72 +62,70 @@ def fermieng(bvec, eig, nelec): | ||
| 62 | 62 | raise ValueError("libtetrabz_fermieng") |
| 63 | 63 | |
| 64 | 64 | |
| 65 | -def occ(bvec, eig): | |
| 65 | +def occ(bvec=numpy.array([1.0, 0.0, 0.0]), eig=numpy.array([0.0])): | |
| 66 | 66 | """ |
| 67 | 67 | Main SUBROUTINE for occupation : Theta(EF - E1) |
| 68 | - :param bvec: | |
| 69 | - :param eig: | |
| 70 | - :return: | |
| 68 | + :param ndarray([3, 3], float) bvec: Reciprocal-lattice vectors | |
| 69 | + :param ndarray([ng0, ng1, ng2, nb], float) eig: Energy eigenvalue | |
| 70 | + :return ndarray([ng0, ng1, ng2, nb], float) wght: Weight | |
| 71 | 71 | """ |
| 72 | 72 | # |
| 73 | 73 | ng = numpy.array(eig.shape[0:3]) |
| 74 | 74 | nk = ng.prod(0) |
| 75 | 75 | nb = eig.shape[3] |
| 76 | 76 | wlsm, ikv = libtetrabz_common.libtetrabz_initialize(ng, bvec) |
| 77 | - | |
| 77 | + # | |
| 78 | 78 | wght = numpy.zeros([ng[0], ng[1], ng[2], nb], dtype=numpy.float_) |
| 79 | - | |
| 80 | - eigt = numpy.empty([20, nb], dtype=numpy.float_) | |
| 79 | + # | |
| 81 | 80 | for it in range(6 * nk): |
| 82 | 81 | # |
| 82 | + eigt = numpy.empty([20, nb], dtype=numpy.float_) | |
| 83 | 83 | for ii in range(20): |
| 84 | 84 | eigt[ii, 0:nb] = eig[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb] |
| 85 | - | |
| 86 | 85 | ei1 = wlsm.dot(eigt) |
| 87 | 86 | # |
| 87 | + w1 = numpy.zeros([nb, 4], dtype=numpy.float_) | |
| 88 | 88 | for ib in range(nb): |
| 89 | 89 | # |
| 90 | - w1 = numpy.zeros(4, dtype=numpy.float_) | |
| 91 | 90 | e = ei1[0:4, ib] |
| 92 | 91 | indx = e.argsort(0) |
| 93 | 92 | e.sort(0) |
| 94 | 93 | # |
| 95 | - if e(1) <= 0.0 < e(2): | |
| 94 | + if e[0] <= 0.0 < e[1]: | |
| 96 | 95 | # |
| 97 | 96 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_a1(e) |
| 98 | - w1[indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 97 | + w1[ib, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 99 | 98 | # |
| 100 | - elif e(2) <= 0.0 < e(3): | |
| 99 | + elif e[1] <= 0.0 < e[2]: | |
| 101 | 100 | # |
| 102 | 101 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b1(e) |
| 103 | - w1[indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 102 | + w1[ib, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 104 | 103 | # |
| 105 | 104 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b2(e) |
| 106 | - w1[indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 105 | + w1[ib, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 107 | 106 | # |
| 108 | 107 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b3(e) |
| 109 | - w1[indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 108 | + w1[ib, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 110 | 109 | # |
| 111 | - elif e(3) <= 0.0 < e(4): | |
| 110 | + elif e[2] <= 0.0 < e[3]: | |
| 112 | 111 | # |
| 113 | 112 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c1(e) |
| 114 | - w1[indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 113 | + w1[ib, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 115 | 114 | # |
| 116 | 115 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c2(e) |
| 117 | - w1[indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 116 | + w1[ib, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 118 | 117 | # |
| 119 | 118 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c3(e) |
| 120 | - w1[indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 121 | - # | |
| 122 | - elif e(4) <= 0.0: | |
| 123 | - # | |
| 124 | - w1[0:4] = 0.25 | |
| 119 | + w1[ib, indx[0:4]] += v * tsmall.sum(0) * 0.25 | |
| 125 | 120 | # |
| 121 | + elif e[3] <= 0.0: | |
| 122 | + w1[ib, 0:4] = 0.25 | |
| 126 | 123 | else: |
| 127 | 124 | continue |
| 128 | 125 | # |
| 129 | - for ii in range(20): | |
| 130 | - wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], ib] += w1.dot(wlsm) | |
| 131 | - # | |
| 126 | + # | |
| 127 | + for ii in range(20): | |
| 128 | + wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb] += w1.dot(wlsm[:, ii]) | |
| 129 | + # | |
| 132 | 130 | wght[0:ng[0], 0:ng[1], 0:ng[2], 0:nb] /= (6.0 * nk) |
| 133 | 131 | return wght |
| @@ -22,7 +22,7 @@ | ||
| 22 | 22 | # |
| 23 | 23 | import math |
| 24 | 24 | import numpy |
| 25 | -import libtetrabz_common | |
| 25 | +from . import libtetrabz_common | |
| 26 | 26 | |
| 27 | 27 | |
| 28 | 28 | def polcmplx(bvec, eig1, eig2, e0): |
| @@ -41,24 +41,21 @@ def polcmplx(bvec, eig1, eig2, e0): | ||
| 41 | 41 | wlsm, ikv = libtetrabz_common.libtetrabz_initialize(ng, bvec) |
| 42 | 42 | |
| 43 | 43 | wght = numpy.zeros([ng[0], ng[1], ng[2], nb, nb, ne], dtype=numpy.complex_) |
| 44 | - | |
| 45 | - eig1t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 46 | - eig2t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 47 | - | |
| 48 | 44 | # |
| 49 | 45 | thr = 1.0e-8 |
| 50 | 46 | for it in range(6 * nk): |
| 51 | 47 | # |
| 48 | + eig1t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 49 | + eig2t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 52 | 50 | for ii in range(20): |
| 53 | 51 | eig1t[ii, 0:nb] = eig1[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb] |
| 54 | 52 | eig2t[ii, 0:nb] = eig2[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb] |
| 55 | - | |
| 56 | 53 | ei1 = wlsm.dot(eig1t) |
| 57 | 54 | ej1 = wlsm.dot(eig2t) |
| 58 | 55 | # |
| 56 | + w1 = numpy.zeros([nb, nb, ne, 4], dtype=numpy.float_) | |
| 59 | 57 | for ib in range(nb): |
| 60 | 58 | # |
| 61 | - w1 = numpy.zeros([nb, 4], dtype=numpy.float_) | |
| 62 | 59 | e = ei1[0:4, ib] |
| 63 | 60 | indx = e.argsort(0) |
| 64 | 61 | e.sort(0) |
| @@ -68,91 +65,78 @@ def polcmplx(bvec, eig1, eig2, e0): | ||
| 68 | 65 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_a1(e) |
| 69 | 66 | # |
| 70 | 67 | if v > thr: |
| 71 | - # | |
| 72 | 68 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 73 | 69 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 74 | 70 | w2 = libtetrabz_polcmplx2(e0, ei2, ej2) |
| 75 | - w1[0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 76 | - # | |
| 71 | + w1[ib, 0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 77 | 72 | # |
| 78 | 73 | elif e(2) <= 0.0 < e[2]: |
| 79 | 74 | # |
| 80 | 75 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b1(e) |
| 81 | 76 | # |
| 82 | 77 | if v > thr: |
| 83 | - # | |
| 84 | 78 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 85 | 79 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 86 | 80 | w2 = libtetrabz_polcmplx2(e0, ei2, ej2) |
| 87 | - w1[0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 88 | - # | |
| 81 | + w1[ib, 0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 89 | 82 | # |
| 90 | 83 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b2(e) |
| 91 | 84 | # |
| 92 | 85 | if v > thr: |
| 93 | - # | |
| 94 | 86 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 95 | 87 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 96 | 88 | w2 = libtetrabz_polcmplx2(e0, ei2, ej2) |
| 97 | - w1[0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 98 | - # | |
| 89 | + w1[ib, 0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 99 | 90 | # |
| 100 | 91 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b3(e) |
| 101 | 92 | # |
| 102 | 93 | if v > thr: |
| 103 | - # | |
| 104 | 94 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 105 | 95 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 106 | 96 | w2 = libtetrabz_polcmplx2(e0, ei2, ej2) |
| 107 | - w1[0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 108 | - # | |
| 97 | + w1[ib, 0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 109 | 98 | # |
| 110 | 99 | elif e[2] <= 0.0 < e[3]: |
| 111 | 100 | # |
| 112 | 101 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c1(e) |
| 113 | 102 | # |
| 114 | 103 | if v > thr: |
| 115 | - # | |
| 116 | 104 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 117 | 105 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 118 | 106 | w2 = libtetrabz_polcmplx2(e0, ei2, ej2) |
| 119 | - w1[0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 120 | - # | |
| 107 | + w1[ib, 0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 121 | 108 | # |
| 122 | 109 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c2(e) |
| 123 | 110 | # |
| 124 | 111 | if v > thr: |
| 125 | - # | |
| 126 | 112 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 127 | 113 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 128 | 114 | w2 = libtetrabz_polcmplx2(e0, ei2, ej2) |
| 129 | - w1[0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 130 | - # | |
| 115 | + w1[ib, 0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 131 | 116 | # |
| 132 | 117 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c3(e) |
| 133 | 118 | # |
| 134 | 119 | if v > thr: |
| 135 | - # | |
| 136 | 120 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 137 | 121 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 138 | 122 | w2 = libtetrabz_polcmplx2(e0, ei2, ej2) |
| 139 | - w1[0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 140 | - # | |
| 123 | + w1[ib, 0:nb, 0:ne, indx[0:4]] += v * w2.dot(tsmall) | |
| 141 | 124 | # |
| 142 | 125 | elif e[3] <= 0.0: |
| 143 | 126 | # |
| 144 | 127 | ei2 = ei1[0:4, ib] |
| 145 | 128 | ej2 = ej1[0:4, 0:nb] |
| 146 | 129 | w2 = libtetrabz_polcmplx2(e0, ei2, ej2) |
| 147 | - w1[0:nb, 0:ne, 0:4] += w2[0:nb, 0:ne, 0:4] | |
| 130 | + w1[ib, 0:nb, 0:ne, 0:4] += w2[0:nb, 0:ne, 0:4] | |
| 148 | 131 | # |
| 149 | 132 | else: |
| 150 | 133 | continue |
| 151 | 134 | # |
| 152 | - for ii in range(20): | |
| 153 | - wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], ib, 0:nb, 0:ne] += w1.dot(wlsm) | |
| 154 | - # | |
| 135 | + for ii in range(20): | |
| 136 | + wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb, 0:nb, 0:ne] += w1.dot(wlsm[:, ii]) | |
| 137 | + # | |
| 155 | 138 | wght[0:ng[0], 0:ng[1], 0:ng[2], 0:nb, 0:nb, 0:ne] /= (6.0 * nk) |
| 139 | + return wght | |
| 156 | 140 | |
| 157 | 141 | |
| 158 | 142 | def libtetrabz_polcmplx2(e0, ei1, ej1): |
| @@ -22,7 +22,7 @@ | ||
| 22 | 22 | # |
| 23 | 23 | import math |
| 24 | 24 | import numpy |
| 25 | -import libtetrabz_common | |
| 25 | +from . import libtetrabz_common | |
| 26 | 26 | |
| 27 | 27 | |
| 28 | 28 | def polstat(bvec, eig1, eig2): |
| @@ -42,106 +42,97 @@ def polstat(bvec, eig1, eig2): | ||
| 42 | 42 | |
| 43 | 43 | wght = numpy.zeros([ng[0], ng[1], ng[2], nb, nb], dtype=numpy.float_) |
| 44 | 44 | |
| 45 | - eig1t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 46 | - eig2t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 47 | 45 | for it in range(6 * nk): |
| 48 | 46 | # |
| 47 | + eig1t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 48 | + eig2t = numpy.empty([20, nb], dtype=numpy.float_) | |
| 49 | 49 | for ii in range(20): |
| 50 | 50 | eig1t[ii, 0:nb] = eig1[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb] |
| 51 | 51 | eig2t[ii, 0:nb] = eig2[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb] |
| 52 | - | |
| 53 | 52 | ei1 = wlsm.dot(eig1t) |
| 54 | 53 | ej1 = wlsm.dot(eig2t) |
| 55 | 54 | # |
| 55 | + w1 = numpy.zeros([nb, nb, 4], dtype=numpy.float_) | |
| 56 | 56 | for ib in range(nb): |
| 57 | 57 | # |
| 58 | - w1 = numpy.zeros([nb, 4], dtype=numpy.float_) | |
| 59 | 58 | e = ei1[0:4, ib] |
| 60 | 59 | indx = e.argsort(0) |
| 61 | 60 | e.sort(0) |
| 62 | - | |
| 61 | + # | |
| 63 | 62 | if e[0] <= 0.0 < e[1]: |
| 64 | 63 | # |
| 65 | 64 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_a1(e) |
| 66 | 65 | # |
| 67 | 66 | if v > thr: |
| 68 | - # | |
| 69 | 67 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 70 | 68 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 71 | 69 | w2 = libtetrabz_polstat2(ei2, ej2) |
| 72 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 70 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 73 | 71 | # |
| 74 | 72 | elif e[1] <= 0.0 < e[2]: |
| 75 | 73 | # |
| 76 | 74 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b1(e) |
| 77 | 75 | # |
| 78 | 76 | if v > thr: |
| 79 | - # | |
| 80 | 77 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 81 | 78 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 82 | 79 | w2 = libtetrabz_polstat2(ei2, ej2) |
| 83 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 80 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 84 | 81 | # |
| 85 | 82 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b2(e) |
| 86 | 83 | # |
| 87 | 84 | if v > thr: |
| 88 | - # | |
| 89 | 85 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 90 | 86 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 91 | 87 | w2 = libtetrabz_polstat2(ei2, ej2) |
| 92 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 88 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 93 | 89 | # |
| 94 | 90 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_b3(e) |
| 95 | 91 | # |
| 96 | 92 | if v > thr: |
| 97 | - # | |
| 98 | 93 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 99 | 94 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 100 | 95 | w2 = libtetrabz_polstat2(ei2, ej2) |
| 101 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 96 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 102 | 97 | # |
| 103 | 98 | elif e[2] <= 0.0 < e[3]: |
| 104 | 99 | # |
| 105 | 100 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c1(e) |
| 106 | 101 | # |
| 107 | 102 | if v > thr: |
| 108 | - # | |
| 109 | 103 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 110 | 104 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 111 | 105 | w2 = libtetrabz_polstat2(ei2, ej2) |
| 112 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 106 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 113 | 107 | # |
| 114 | 108 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c2(e) |
| 115 | 109 | # |
| 116 | 110 | if v > thr: |
| 117 | - # | |
| 118 | 111 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 119 | 112 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 120 | 113 | w2 = libtetrabz_polstat2(ei2, ej2) |
| 121 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 114 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 122 | 115 | # |
| 123 | 116 | v, tsmall = libtetrabz_common.libtetrabz_tsmall_c3(e) |
| 124 | 117 | # |
| 125 | 118 | if v > thr: |
| 126 | - # | |
| 127 | 119 | ei2 = tsmall.dot(ei1[indx[0:4], ib]) |
| 128 | 120 | ej2 = tsmall.dot(ej1[indx[0:4], 0:nb]) |
| 129 | 121 | w2 = libtetrabz_polstat2(ei2, ej2) |
| 130 | - w1[0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 131 | - # | |
| 132 | - elif e[3] <= 0.0: | |
| 122 | + w1[ib, 0:nb, indx[0:4]] += v * w2.dot(tsmall) | |
| 133 | 123 | # |
| 124 | + elif e[3] <= 0.0: | |
| 134 | 125 | ei2 = ei1[0:4, ib] |
| 135 | 126 | ej2 = ej1[0:4, 0:nb] |
| 136 | 127 | w2 = libtetrabz_polstat2(ei2, ej2) |
| 137 | - w1[0:nb, 0:4] += w2[0:nb, 0:4] | |
| 138 | - # | |
| 128 | + w1[ib, 0:nb, 0:4] += w2[0:nb, 0:4] | |
| 139 | 129 | else: |
| 140 | 130 | continue |
| 141 | 131 | # |
| 142 | - for ii in range(20): | |
| 143 | - wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], ib, 0:nb] += w1.dot(wlsm) | |
| 144 | - # | |
| 132 | + # | |
| 133 | + for ii in range(20): | |
| 134 | + wght[ikv[it, ii, 0], ikv[it, ii, 1], ikv[it, ii, 2], 0:nb, 0:nb] += w1.dot(wlsm[:, ii]) | |
| 135 | + # | |
| 145 | 136 | wght[0:ng[0], 0:ng[1], 0:ng[2], 0:nb, 0:nb] /= (6.0 * nk) |
| 146 | 137 | |
| 147 | 138 |
libtetrabz
Fork