Symmetric product of irreps associated with qvectors¶
There are 4 key classes here:
- productQ: Represents how Q transform in the Q-star under symmetry operation of the point group.
- symmetricProductQ: Represents how Q transform in the Q-star under symmetry operation of the point group, with an extra constraint that the order of the q-identifier pair does not matter.
- product_from_qvecirreps: Product representation of irreps associated with q-vectors.
- product_from_qvecirreps: Symmetric product representation of irreps associated with q-vectors.
Product representation of irreps associated with q-vectors.¶
In order to analysis the reducibility of a dynamic tensor of a given structure at a given Q (of a given order), one needs to construct in the symmetric basis of the q within the Q, the symmetric products of q and irrep pairs, and analyse how each product transform within the Q-star under the symmetry operators of the point group of the structure. And it gives rise to this object.
Unlike the regular product of irreps, it is taking a product with a series of q and irrep pairs, taking into consideration that q-vectors can rotate into other q-vectors when irreps are under rotation (They usually does not change at all though).
There are two ways to implement this. The first is the naive one, which, after constructing the irreps in the little group of q, we simply rotates the irreps of the origin q and project on to the resulting q irreps, and the projection would determine the phases in the matrix representation of the group, of each group operation. The disadvantage here is that we are not able to know the phases a piori. In order to resolve this, we propose the second approach, which pre-select the phases from the star basis of q, and consequently the irreps of q would transform like the corresponding irreps in the big group of the phases we choose. Then to see it in a different perspective this product is just the direct product of the point group representation of Q in Qstar with the product of irreps (the corresponding parents in the big groups of the chosen phases). We here implement the second approach.
Example:
Let’s take an example of the Q=MaMbMx point in graphene. We can know the irreps of each q in Q by decomposing at the little group of q, and we also know that Ma, Mb and Mx came from the same q-star. Thus in order to ensure consistent phase, it would be better that we construct the irreps in the star. And we can also find the parent irreps of the irreps of q in the star.
Then we can look in to one particular product, at point group D6h and little group D2h
Note that in this particular case, the irreps of the q’s in their respective little group have the same name as their parents in the star.
The product of the irreps would be
And given they are 1-D irreps and they only rotate into themselves in D6h by construction, the matrix representation of the product in the point group would all be 1x1 matrices of 1.
But the Q-star has \(3! = 6\) different permutations and thus has a 6 dimensional representation.
Eventually, the representation of the q-irrep pair would be the direct product of the above mentioned two representaions.
Symmetric product representation of irreps associated with q-vectors.¶
It takes one more step from product_from_qvecirreps, exploit the permutation symmetry of products, and construct the symmetric product of q-vector, irrep pairs.
Example:
Follow the same example in the symmetry.symmetric_product_from_qvecirreps.product_from_qvecirreps_
We have 6 permutations
And we know they are permutationally different, but if we take a different set of irreps
We have 6 permutations
Then we know some of them are permutationally equivalent and we can reduce the number of basis to 3
The whole symmetric product procedure is exactly the ordinary symmetric product, and will not be further discuessed here.
Args: - pg: Point group under which the analysis will be proformed. - irrep_inputs: The q-irreps to product. - rvec: The reciprocal lattice vectors need to rotate q-vectors
[5]:
from fractions import Fraction
from periodica import structure
from symmetric_product_from_qvecirreps import (
productQ,
symmetricProductQ,
product_from_qvecirreps,
symmetric_product_from_qvecirreps,
)
from coordinate_tools import coordinate_parse, table_text, coord_to_string as c2s
[3]:
poscar = """\
graphene
1.00000000000000
2.1217113285639000 1.2249706066897641 0.0000000000000000
2.1217113285639000 -1.2249706066897641 0.0000000000000000
0.0000000000000000 0.0000000000000000 -15.0000000000000000
2
Direct
0.00000000 0.00000000 0.0000000000000000 C:p
0.33333333 0.33333333 0.0000000000000000 C:p
""".strip()
Here is the first example listed above:
[25]:
qvecs = coordinate_parse("1/2 0 0; 0 1/2 0; 1/2 1/2 0", Fraction).get_coord_list()
irrep_input = [(qvecs[0], ("A2g", 0)), (qvecs[1], ("B1u", 0)), (qvecs[2], ("B2u", 0))]
print c2s(irrep_input)
spd = symmetricProductQ("D6h", irrep_input, structure(poscar).rvec)
print spd.irrep_counter
print
print c2s(irrep_input)
pd = productQ("D6h", irrep_input, structure(poscar).rvec)
print pd.irrep_counter
(((1/2, 0, 0), (A2g, 0)), ((0, 1/2, 0), (B1u, 0)), ((1/2, 1/2, 0), (B2u, 0)))
OrderedDict([('A1g', 1), ('A2g', 1), ('E2g', 2)])
(((1/2, 0, 0), (A2g, 0)), ((0, 1/2, 0), (B1u, 0)), ((1/2, 1/2, 0), (B2u, 0)))
OrderedDict([('A1g', 1), ('A2g', 1), ('E2g', 2)])
[26]:
map(c2s, pd.basis)
[26]:
['(((0, 1/2, 0), (A2g, 0)), ((1/2, 0, 0), (B1u, 0)), ((1/2, 1/2, 0), (B2u, 0)))',
'(((0, 1/2, 0), (A2g, 0)), ((1/2, 1/2, 0), (B1u, 0)), ((1/2, 0, 0), (B2u, 0)))',
'(((1/2, 0, 0), (A2g, 0)), ((0, 1/2, 0), (B1u, 0)), ((1/2, 1/2, 0), (B2u, 0)))',
'(((1/2, 0, 0), (A2g, 0)), ((1/2, 1/2, 0), (B1u, 0)), ((0, 1/2, 0), (B2u, 0)))',
'(((1/2, 1/2, 0), (A2g, 0)), ((0, 1/2, 0), (B1u, 0)), ((1/2, 0, 0), (B2u, 0)))',
'(((1/2, 1/2, 0), (A2g, 0)), ((1/2, 0, 0), (B1u, 0)), ((0, 1/2, 0), (B2u, 0)))']
[27]:
map(c2s, spd.basis)
[27]:
['(((0, 1/2, 0), (A2g, 0)), ((1/2, 0, 0), (B1u, 0)), ((1/2, 1/2, 0), (B2u, 0)))',
'(((0, 1/2, 0), (A2g, 0)), ((1/2, 0, 0), (B2u, 0)), ((1/2, 1/2, 0), (B1u, 0)))',
'(((0, 1/2, 0), (B1u, 0)), ((1/2, 0, 0), (A2g, 0)), ((1/2, 1/2, 0), (B2u, 0)))',
'(((0, 1/2, 0), (B1u, 0)), ((1/2, 0, 0), (B2u, 0)), ((1/2, 1/2, 0), (A2g, 0)))',
'(((0, 1/2, 0), (B2u, 0)), ((1/2, 0, 0), (A2g, 0)), ((1/2, 1/2, 0), (B1u, 0)))',
'(((0, 1/2, 0), (B2u, 0)), ((1/2, 0, 0), (B1u, 0)), ((1/2, 1/2, 0), (A2g, 0)))']
Here is the second example:
[32]:
qvecs = coordinate_parse("1/2 0 0; 0 1/2 0; 1/2 1/2 0", Fraction).get_coord_list()
irrep_input = [(qvecs[0], ("A2g", 0)), (qvecs[1], ("B1u", 0)), (qvecs[2], ("B1u", 0))]
print c2s(irrep_input)
spd = symmetricProductQ("D6h", irrep_input, structure(poscar).rvec)
print spd.irrep_counter
print
print c2s(irrep_input)
pd = productQ("D6h", irrep_input, structure(poscar).rvec)
print pd.irrep_counter
(((1/2, 0, 0), (A2g, 0)), ((0, 1/2, 0), (B1u, 0)), ((1/2, 1/2, 0), (B1u, 0)))
OrderedDict([('A1g', 1), ('E2g', 1)])
(((1/2, 0, 0), (A2g, 0)), ((0, 1/2, 0), (B1u, 0)), ((1/2, 1/2, 0), (B1u, 0)))
OrderedDict([('A1g', 1), ('A2g', 1), ('E2g', 2)])
[33]:
map(c2s, pd.basis)
[33]:
['(((0, 1/2, 0), (A2g, 0)), ((1/2, 0, 0), (B1u, 0)), ((1/2, 1/2, 0), (B1u, 0)))',
'(((0, 1/2, 0), (A2g, 0)), ((1/2, 1/2, 0), (B1u, 0)), ((1/2, 0, 0), (B1u, 0)))',
'(((1/2, 0, 0), (A2g, 0)), ((0, 1/2, 0), (B1u, 0)), ((1/2, 1/2, 0), (B1u, 0)))',
'(((1/2, 0, 0), (A2g, 0)), ((1/2, 1/2, 0), (B1u, 0)), ((0, 1/2, 0), (B1u, 0)))',
'(((1/2, 1/2, 0), (A2g, 0)), ((0, 1/2, 0), (B1u, 0)), ((1/2, 0, 0), (B1u, 0)))',
'(((1/2, 1/2, 0), (A2g, 0)), ((1/2, 0, 0), (B1u, 0)), ((0, 1/2, 0), (B1u, 0)))']
[34]:
map(c2s, spd.basis)
[34]:
['(((0, 1/2, 0), (A2g, 0)), ((1/2, 0, 0), (B1u, 0)), ((1/2, 1/2, 0), (B1u, 0)))',
'(((0, 1/2, 0), (B1u, 0)), ((1/2, 0, 0), (A2g, 0)), ((1/2, 1/2, 0), (B1u, 0)))',
'(((0, 1/2, 0), (B1u, 0)), ((1/2, 0, 0), (B1u, 0)), ((1/2, 1/2, 0), (A2g, 0)))']
[ ]: