def get_wigner_dmat(quant_2j, alpha, beta, gamma): """ Given quantum number and Euler angles, return the Wigner-D matrix. Parameters ---------- quant_2j: int Twice of the quantum number j: 2j, for example, quant_2j=1 means j=1/2, quant_2j=2 means j=1 alpha: float number The first Euler angle :math:`\\alpha` in radian [0, :math:`2\\pi`]. beta: float number The second Euler angle :math:`\\beta` in radian [0, :math:`\\pi`]. gamma: float number The third Euler angle :math:`\\gamma` in radian [0, :math:`2\\pi`]. Returns ------- result: 2d complex array, shape(quant_2j+1, quant_2j+1) The Wigner D-matrix. For :math:`j=1/2`, the orbital order is: +1/2 (spin up), -1/2 (spin down). For :math:`j>1/2`, the orbital order is: :math:`-j, -j+1, ..., +j` Examples -------- >>> import edrixs spin-1/2 D-matrix >>> edrixs.get_wigner_dmat(1, 1, 2, 3) array([[-0.224845-0.491295j, -0.454649-0.708073j], [ 0.454649-0.708073j, -0.224845+0.491295j]]) j=1 D-matrix >>> edrixs.get_wigner_dmat(2, 1, 2, 3) array([[-0.190816-0.220931j, 0.347398+0.541041j, -0.294663-0.643849j], [ 0.636536-0.090736j, -0.416147+0.j , -0.636536-0.090736j], [-0.294663+0.643849j, -0.347398+0.541041j, -0.190816+0.220931j]]) """ from sympy.physics.quantum.spin import Rotation from sympy import N, S ndim = quant_2j + 1 result = np.zeros((ndim, ndim), dtype=np.complex) # For j=1/2, we use different orbital order: first +1/2, then -1/2 if quant_2j == 1: for i, mi in enumerate(range(quant_2j, -quant_2j-1, -2)): for j, mj in enumerate(range(quant_2j, -quant_2j-1, -2)): rot = Rotation.D(S(quant_2j)/2, S(mi)/2, S(mj)/2, alpha, beta, gamma) result[i, j] = N(rot.doit()) # For j > 1/2, the order is -j, -j+1, ..., +j else: for i, mi in enumerate(range(-quant_2j, quant_2j+1, 2)): for j, mj in enumerate(range(-quant_2j, quant_2j+1, 2)): rot = Rotation.D(S(quant_2j)/2, S(mi)/2, S(mj)/2, alpha, beta, gamma) result[i, j] = N(rot.doit()) return result
def get_steering_matrix(degreeMax, ksize, M): ''' Returns a tensor of a block diagonal matrix Sr for the M orientations: i.e. a matrix of weights of shape ((degreeMax+1)**2,(degreeMax+1)**2) for each orientation. The output Sr has shape (M,(degreeMax+1)**2,(degreeMax+1)**2)). (degreeMax+1)**2 is the total number of Ynm, it comes from the sum_n(2n+1) degreeMax: maximal SH degree ksize: kernel size M: number of orientations ''' radius = (ksize - 1) / 2 radiusAug = int(np.ceil((radius - 1) * np.sqrt(3)) + 1) ksizeAug = radiusAug * 2 + 1 # define search space for angles. zyz = get_euler_angles(M) _, theta, phi = getSphCoordArrays(ksize) Sr = np.zeros((M, (degreeMax + 1)**2, (degreeMax + 1)**2), dtype=np.complex64) # scan through angles for a in range(zyz.shape[0]): alpha, beta, gamma = zyz[a] * pi / 180 # Import Wigner D matrix directly from simpy for n in range(degreeMax + 1): for k1 in range(n * 2 + 1): m1 = k1 - n for k2 in range(n * 2 + 1): m2 = k2 - n Sr[a, n**2 + k1, n**2 + k2] = np.complex( Rotation.D(n, m1, m2, alpha, beta, gamma).doit()) return tf.constant(Sr)
def wignerRotation(V1, l, powerSpec): z1 = V1[0] t1 = V1[1] p1 = V1[2] Vr1 = np.array([-tf.ZtoN(z1), t1, p1]) elDm1 = lambda m1, m2: Rotation.D(2, m2, m1, -t1, p1, 0).doit() #elDm2 = lambda m1,m2: Rotation.D(2,m2,m1,-t2,p2,0).doit() #corelation = np.zeros((5,5)).astype(complex) var = aBarCor(Vr1, l, powerSpec, V1[0]) #var is the <aBar2m1 aBar*2m2> matrix MatDm1 = np.zeros((5, 5)).astype(complex) #The wigner matrix #MatDm2 = np.zeros((5,5)).astype(complex) for i in range(-2, 3): for j in range(-2, 3): MatDm1[i + 2][j + 2] = elDm1(i, j) #MatDm2[i+2][j+2] = np.conjugate(elDm2(i,j)) #print("var:\n", var, "\n MatDm1: \n", MatDm1,"\n MatDm2: \n", MatDm2) #corelation = np.linalg.multi_dot([MatDm1,var,np.transpose((MatDm2))])#matrix after rotation by the respective #wignerD matrices #print("Before rotation (A2m bar):\n:", var, "\n After Wigner rotation(A2m):\n", corelation) corelation = np.matmul(MatDm1, var) return corelation, var, MatDm1
def wignerRotation(V1, V2): z1 = V1[0] t1 = V1[1] p1 = V1[2] z2 = V2[0] t2 = V2[1] p2 = V2[2] Vr1 = np.array([-tf.ZtoN(z1), t1, p1]) Vr2 = np.array([-tf.ZtoN(z2), t2, p2]) elDm1 = lambda m1, m2: sp.N(Rotation.D(2, m2, m1, -p1, t1, 0).doit( )) #using physics convention: phi is the azimuth (in x-y plane) elDm2 = lambda m1, m2: sp.N(Rotation.D(2, m2, m1, -p2, t2, 0).doit()) delR = deltaR(Vr1, Vr2) Integrand = np.zeros( 5) #store the values of Ils to save computational time for i in range(0, len(Integrand), 2): Integrand[i] = I(i, delR, z1, z2) #toDo: pass in delR rather than Vr1 and Vr2; #same thing for aBarCor(Vr1 and Vr2 are only used in spherHarm) corelation = np.zeros((5, 5)).astype(complex) MatDm1 = np.zeros((5, 5)).astype(complex) #The two wigner matrices MatDm2 = np.zeros((5, 5)).astype(complex) for i in range(-2, 3): for j in range(-2, 3): MatDm1[i + 2][j + 2] = elDm1(i, j) MatDm2[i + 2][j + 2] = np.conjugate(elDm2(i, j)) #MatDm1[i+2][j+2] = np.conjugate(elDm1(i,j)) #MatDm2[i+2][j+2] = elDm2(i,j) var = aBarCor(delR, Integrand) #var is the <aBar2m1 aBar*2m2> matrix #print("var:\n", var, "\n MatDm1: \n", MatDm1,"\n MatDm2: \n", MatDm2) #corelation = np.linalg.multi_dot([np.transpose(MatDm1),var,(MatDm2)]) corelation = np.linalg.multi_dot([(MatDm1), var, np.transpose(MatDm2)]) #print("Before rotation (A2m bar):\n:", var, "\n After Wigner rotation(A2m):\n", corelation) return corelation, var, MatDm1, MatDm2
def __prepare_WignerD_alpha0(self): s = sympy.S(self._q - 1) / 2 theta, phi, c = sympy.symbols('theta phi c') Ds = sympy.Array([[ Rotation.D(s, s - i, s - j, 0, -theta, -phi).doit() for j in range(self._q) ] for i in range(self._q)]) # Ds = Ds.subs(theta,sympy.acos(c)) self.__WignerD_alpha0 = sympy.lambdify((theta, phi), Ds, 'numpy')
def formulate_wigner_d(transition: StateTransition, node_id: int) -> sp.Expr: r"""Compute `~sympy.physics.quantum.spin.WignerD` for a transition node. Following :cite:`kutschkeAngularDistributionCookbook1996`, Eq. (10). For a two-body decay :math:`1 \to 2, 3`, we get .. math:: D^{s_1}_{m_1,\lambda_2-\lambda_3}(-\phi,\theta,0) :label: formulate_wigner_d with: - :math:`s_1` the `Spin.magnitude <qrules.particle.Spin.magnitude>` of the decaying state, - :math:`m_1` the `~qrules.transition.State.spin_projection` of the decaying state, - :math:`\lambda_{2}, \lambda_{3}` the helicities of the decay products in in the restframe of :math:`1` (can be taken to be their intrinsic `~qrules.transition.State.spin_projection` when following a constistent boosting procedure), - and :math:`\phi` and :math:`\theta` the helicity angles (see also :func:`.get_helicity_angle_label`). Note that :math:`\lambda_2, \lambda_3` are ordered by their number of children, then by their state ID (see :class:`.TwoBodyDecay`). See :cite:`kutschkeAngularDistributionCookbook1996`, Eq. (30) for an example of Wigner-:math:`D` functions in a *sequential* two-body decay. Example ------- >>> import qrules >>> reaction = qrules.generate_transitions( ... initial_state=[("J/psi(1S)", [+1])], ... final_state=[("gamma", [-1]), "f(0)(980)"], ... ) >>> transition = reaction.transitions[0] >>> formulate_wigner_d(transition, node_id=0) WignerD(1, 1, -1, -phi_0, theta_0, 0) .. math:: D^{s_1}_{m_1,\lambda_2-\lambda_3}\left(-\phi,\theta,0\right) = D^{1}_{+1,(-1-0)}\left(-\phi_0,\theta_0,0\right) = D^{1}_{1,-1}\left(-\phi_0,\theta_0,0\right) """ from sympy.physics.quantum.spin import Rotation as Wigner decay = TwoBodyDecay.from_transition(transition, node_id) _, phi, theta = _generate_kinematic_variables(transition, node_id) return Wigner.D( j=sp.Rational(decay.parent.particle.spin), m=sp.Rational(decay.parent.spin_projection), mp=sp.Rational(decay.children[0].spin_projection - decay.children[1].spin_projection), alpha=-phi, beta=theta, gamma=0, )
def WignerRotation(cluster, l, ps): z = cluster[0] t1 = cluster[1] p1 = cluster[2] elDm = lambda m1, m2: Rotation.D(l, m1, m2, -t1, p1, 0).doit() MatDm = np.zeros((2 * l + 1, 5)).astype(complex) for m2 in range(-2, 3): for m1 in range(-l, l + 1): MatDm[m1 + l][m2 + 2] = elDm(m1, m2) temp = CorMatrix(l, z, ps) corelation = np.linalg.multi_dot([MatDm, temp]) return corelation
def wignerRotation(V1, l): z1 = V1[0] t1 = V1[1] p1 = V1[2] Vr1 = np.array([-tf.ZtoN(z1), t1, p1]) elDm1 = lambda m1, m2: Rotation.D(2, m2, m1, -p1, t1, 0).doit() var = aBarCor(Vr1, l, V1[0]) #var is the <aBar2m1 aBar*2m2> matrix MatDm1 = np.zeros((5, 5)).astype(complex) #The wigner matrix for i in range(-2, 3): for j in range(-2, 3): MatDm1[i + 2][j + 2] = elDm1(i, j) corelation = np.matmul(MatDm1, var) return corelation, var, MatDm1
def test_wignerd(): j, m, mp, alpha, beta, gamma = symbols('j m mp alpha beta gamma') assert Rotation.D(j, m, mp, alpha, beta, gamma) == WignerD(j, m, mp, alpha, beta, gamma) assert Rotation.d(j, m, mp, beta) == WignerD(j, m, mp, 0, beta, 0)
def test_rotation_d(): # Symbolic tests alpha, beta, gamma = symbols('alpha beta gamma') # j = 1/2 assert Rotation.D(S(1) / 2, S(1) / 2, S(1) / 2, alpha, beta, gamma).doit() == cos( beta / 2) * exp(-I * alpha / 2) * exp(-I * gamma / 2) assert Rotation.D(S(1) / 2, S(1) / 2, -S(1) / 2, alpha, beta, gamma).doit() == -sin(beta / 2) * exp( -I * alpha / 2) * exp(I * gamma / 2) assert Rotation.D(S(1) / 2, -S(1) / 2, S(1) / 2, alpha, beta, gamma).doit() == sin( beta / 2) * exp(I * alpha / 2) * exp(-I * gamma / 2) assert Rotation.D(S(1) / 2, -S(1) / 2, -S(1) / 2, alpha, beta, gamma).doit() == cos(beta / 2) * exp( I * alpha / 2) * exp(I * gamma / 2) # j = 1 assert Rotation.D(1, 1, 1, alpha, beta, gamma).doit() == (1 + cos(beta)) / 2 * exp( -I * alpha) * exp(-I * gamma) assert Rotation.D(1, 1, 0, alpha, beta, gamma).doit() == -sin(beta) / sqrt(2) * exp(-I * alpha) assert Rotation.D( 1, 1, -1, alpha, beta, gamma).doit() == (1 - cos(beta)) / 2 * exp(-I * alpha) * exp(I * gamma) assert Rotation.D(1, 0, 1, alpha, beta, gamma).doit() == sin(beta) / sqrt(2) * exp(-I * gamma) assert Rotation.D(1, 0, 0, alpha, beta, gamma).doit() == cos(beta) assert Rotation.D(1, 0, -1, alpha, beta, gamma).doit() == -sin(beta) / sqrt(2) * exp(I * gamma) assert Rotation.D( 1, -1, 1, alpha, beta, gamma).doit() == (1 - cos(beta)) / 2 * exp(I * alpha) * exp(-I * gamma) assert Rotation.D(1, -1, 0, alpha, beta, gamma).doit() == sin(beta) / sqrt(2) * exp(I * alpha) assert Rotation.D( 1, -1, -1, alpha, beta, gamma).doit() == (1 + cos(beta)) / 2 * exp(I * alpha) * exp(I * gamma) # j = 3/2 assert Rotation.D( S(3) / 2, S(3) / 2, S(3) / 2, alpha, beta, gamma).doit() == (3 * cos(beta / 2) + cos(3 * beta / 2)) / 4 * exp( -3 * I * alpha / 2) * exp(-3 * I * gamma / 2) assert Rotation.D( S(3) / 2, S(3) / 2, S(1) / 2, alpha, beta, gamma).doit() == sqrt(3) * (-sin(beta / 2) - sin( 3 * beta / 2)) / 4 * exp(-3 * I * alpha / 2) * exp(-I * gamma / 2) assert Rotation.D( S(3) / 2, S(3) / 2, -S(1) / 2, alpha, beta, gamma).doit() == sqrt(3) * (cos(beta / 2) - cos( 3 * beta / 2)) / 4 * exp(-3 * I * alpha / 2) * exp(I * gamma / 2) assert Rotation.D( S(3) / 2, S(3) / 2, -S(3) / 2, alpha, beta, gamma).doit() == (-3 * sin(beta / 2) + sin(3 * beta / 2)) / 4 * exp( -3 * I * alpha / 2) * exp(3 * I * gamma / 2) assert Rotation.D( S(3) / 2, S(1) / 2, S(3) / 2, alpha, beta, gamma).doit() == sqrt(3) * (sin(beta / 2) + sin( 3 * beta / 2)) / 4 * exp(-I * alpha / 2) * exp(-3 * I * gamma / 2) assert Rotation.D( S(3) / 2, S(1) / 2, S(1) / 2, alpha, beta, gamma).doit() == (cos(beta / 2) + 3 * cos(3 * beta / 2)) / 4 * exp( -I * alpha / 2) * exp(-I * gamma / 2) assert Rotation.D( S(3) / 2, S(1) / 2, -S(1) / 2, alpha, beta, gamma).doit() == (sin(beta / 2) - 3 * sin(3 * beta / 2)) / 4 * exp( -I * alpha / 2) * exp(I * gamma / 2) assert Rotation.D( S(3) / 2, S(1) / 2, -S(3) / 2, alpha, beta, gamma).doit() == sqrt(3) * (cos(beta / 2) - cos( 3 * beta / 2)) / 4 * exp(-I * alpha / 2) * exp(3 * I * gamma / 2) assert Rotation.D( S(3) / 2, -S(1) / 2, S(3) / 2, alpha, beta, gamma).doit() == sqrt(3) * (cos(beta / 2) - cos( 3 * beta / 2)) / 4 * exp(I * alpha / 2) * exp(-3 * I * gamma / 2) assert Rotation.D( S(3) / 2, -S(1) / 2, S(1) / 2, alpha, beta, gamma).doit() == (-sin(beta / 2) + 3 * sin(3 * beta / 2)) / 4 * exp( I * alpha / 2) * exp(-I * gamma / 2) assert Rotation.D( S(3) / 2, -S(1) / 2, -S(1) / 2, alpha, beta, gamma).doit() == (cos(beta / 2) + 3 * cos(3 * beta / 2)) / 4 * exp( I * alpha / 2) * exp(I * gamma / 2) assert Rotation.D( S(3) / 2, -S(1) / 2, -S(3) / 2, alpha, beta, gamma).doit() == sqrt(3) * (-sin(beta / 2) - sin( 3 * beta / 2)) / 4 * exp(I * alpha / 2) * exp(3 * I * gamma / 2) assert Rotation.D( S(3) / 2, -S(3) / 2, S(3) / 2, alpha, beta, gamma).doit() == (3 * sin(beta / 2) - sin(3 * beta / 2)) / 4 * exp( 3 * I * alpha / 2) * exp(-3 * I * gamma / 2) assert Rotation.D( S(3) / 2, -S(3) / 2, S(1) / 2, alpha, beta, gamma).doit() == sqrt(3) * (cos(beta / 2) - cos( 3 * beta / 2)) / 4 * exp(3 * I * alpha / 2) * exp(-I * gamma / 2) assert Rotation.D( S(3) / 2, -S(3) / 2, -S(1) / 2, alpha, beta, gamma).doit() == sqrt(3) * (sin(beta / 2) + sin( 3 * beta / 2)) / 4 * exp(3 * I * alpha / 2) * exp(I * gamma / 2) assert Rotation.D( S(3) / 2, -S(3) / 2, -S(3) / 2, alpha, beta, gamma).doit() == (3 * cos(beta / 2) + cos(3 * beta / 2)) / 4 * exp( 3 * I * alpha / 2) * exp(3 * I * gamma / 2) # j = 2 assert Rotation.D( 2, 2, 2, alpha, beta, gamma).doit() == (3 + 4 * cos(beta) + cos(2 * beta)) / 8 * exp( -2 * I * alpha) * exp(-2 * I * gamma) assert Rotation.D( 2, 2, 1, alpha, beta, gamma).doit() == (-2 * sin(beta) - sin(2 * beta)) / 4 * exp( -2 * I * alpha) * exp(-I * gamma) assert Rotation.D(2, 2, 0, alpha, beta, gamma).doit() == sqrt(6) * (1 - cos(2 * beta)) / 8 * exp( -2 * I * alpha) assert Rotation.D( 2, 2, -1, alpha, beta, gamma).doit() == (-2 * sin(beta) + sin(2 * beta)) / 4 * exp( -2 * I * alpha) * exp(I * gamma) assert Rotation.D( 2, 2, -2, alpha, beta, gamma).doit() == (3 - 4 * cos(beta) + cos(2 * beta)) / 8 * exp( -2 * I * alpha) * exp(2 * I * gamma) assert Rotation.D( 2, 1, 2, alpha, beta, gamma).doit() == (2 * sin(beta) + sin(2 * beta)) / 4 * exp( -I * alpha) * exp(-2 * I * gamma) assert Rotation.D(2, 1, 1, alpha, beta, gamma).doit() == (cos(beta) + cos(2 * beta)) / 2 * exp( -I * alpha) * exp(-I * gamma) assert Rotation.D( 2, 1, 0, alpha, beta, gamma).doit() == -sqrt(6) * sin(2 * beta) / 4 * exp(-I * alpha) assert Rotation.D(2, 1, -1, alpha, beta, gamma).doit() == (cos(beta) - cos(2 * beta)) / 2 * exp( -I * alpha) * exp(I * gamma) assert Rotation.D( 2, 1, -2, alpha, beta, gamma).doit() == (-2 * sin(beta) + sin(2 * beta)) / 4 * exp( -I * alpha) * exp(2 * I * gamma) assert Rotation.D(2, 0, 2, alpha, beta, gamma).doit() == sqrt(6) * (1 - cos(2 * beta)) / 8 * exp( -2 * I * gamma) assert Rotation.D( 2, 0, 1, alpha, beta, gamma).doit() == sqrt(6) * sin(2 * beta) / 4 * exp(-I * gamma) assert Rotation.D(2, 0, 0, alpha, beta, gamma).doit() == (1 + 3 * cos(2 * beta)) / 4 assert Rotation.D( 2, 0, -1, alpha, beta, gamma).doit() == -sqrt(6) * sin(2 * beta) / 4 * exp(I * gamma) assert Rotation.D( 2, 0, -2, alpha, beta, gamma).doit() == sqrt(6) * (1 - cos(2 * beta)) / 8 * exp(2 * I * gamma) assert Rotation.D( 2, -1, 2, alpha, beta, gamma).doit() == (2 * sin(beta) - sin(2 * beta)) / 4 * exp( I * alpha) * exp(-2 * I * gamma) assert Rotation.D(2, -1, 1, alpha, beta, gamma).doit() == (cos(beta) - cos(2 * beta)) / 2 * exp( I * alpha) * exp(-I * gamma) assert Rotation.D( 2, -1, 0, alpha, beta, gamma).doit() == sqrt(6) * sin(2 * beta) / 4 * exp(I * alpha) assert Rotation.D(2, -1, -1, alpha, beta, gamma).doit() == (cos(beta) + cos(2 * beta)) / 2 * exp( I * alpha) * exp(I * gamma) assert Rotation.D( 2, -1, -2, alpha, beta, gamma).doit() == (-2 * sin(beta) - sin(2 * beta)) / 4 * exp( I * alpha) * exp(2 * I * gamma) assert Rotation.D( 2, -2, 2, alpha, beta, gamma).doit() == (3 - 4 * cos(beta) + cos(2 * beta)) / 8 * exp( 2 * I * alpha) * exp(-2 * I * gamma) assert Rotation.D( 2, -2, 1, alpha, beta, gamma).doit() == (2 * sin(beta) - sin(2 * beta)) / 4 * exp( 2 * I * alpha) * exp(-I * gamma) assert Rotation.D( 2, -2, 0, alpha, beta, gamma).doit() == sqrt(6) * (1 - cos(2 * beta)) / 8 * exp(2 * I * alpha) assert Rotation.D( 2, -2, -1, alpha, beta, gamma).doit() == (2 * sin(beta) + sin(2 * beta)) / 4 * exp( 2 * I * alpha) * exp(I * gamma) assert Rotation.D( 2, -2, -2, alpha, beta, gamma).doit() == (3 + 4 * cos(beta) + cos(2 * beta)) / 8 * exp( 2 * I * alpha) * exp(2 * I * gamma) # Numerical tests # j = 1/2 assert Rotation.D(S(1) / 2, S(1) / 2, S(1) / 2, pi / 2, pi / 2, pi / 2).doit() == -I * sqrt(2) / 2 assert Rotation.D(S(1) / 2, S(1) / 2, -S(1) / 2, pi / 2, pi / 2, pi / 2).doit() == -sqrt(2) / 2 assert Rotation.D(S(1) / 2, -S(1) / 2, S(1) / 2, pi / 2, pi / 2, pi / 2).doit() == sqrt(2) / 2 assert Rotation.D(S(1) / 2, -S(1) / 2, -S(1) / 2, pi / 2, pi / 2, pi / 2).doit() == I * sqrt(2) / 2 # j = 1 assert Rotation.D(1, 1, 1, pi / 2, pi / 2, pi / 2).doit() == -1 / 2 assert Rotation.D(1, 1, 0, pi / 2, pi / 2, pi / 2).doit() == I * sqrt(2) / 2 assert Rotation.D(1, 1, -1, pi / 2, pi / 2, pi / 2).doit() == 1 / 2 assert Rotation.D(1, 0, 1, pi / 2, pi / 2, pi / 2).doit() == -I * sqrt(2) / 2 assert Rotation.D(1, 0, 0, pi / 2, pi / 2, pi / 2).doit() == 0 assert Rotation.D(1, 0, -1, pi / 2, pi / 2, pi / 2).doit() == -I * sqrt(2) / 2 assert Rotation.D(1, -1, 1, pi / 2, pi / 2, pi / 2).doit() == 1 / 2 assert Rotation.D(1, -1, 0, pi / 2, pi / 2, pi / 2).doit() == I * sqrt(2) / 2 assert Rotation.D(1, -1, -1, pi / 2, pi / 2, pi / 2).doit() == -1 / 2 # j = 3/2 assert Rotation.D(S(3) / 2, S(3) / 2, S(3) / 2, pi / 2, pi / 2, pi / 2).doit() == I * sqrt(2) / 4 assert Rotation.D(S(3) / 2, S(3) / 2, S(1) / 2, pi / 2, pi / 2, pi / 2).doit() == sqrt(6) / 4 assert Rotation.D(S(3) / 2, S(3) / 2, -S(1) / 2, pi / 2, pi / 2, pi / 2).doit() == -I * sqrt(6) / 4 assert Rotation.D(S(3) / 2, S(3) / 2, -S(3) / 2, pi / 2, pi / 2, pi / 2).doit() == -sqrt(2) / 4 assert Rotation.D(S(3) / 2, S(1) / 2, S(3) / 2, pi / 2, pi / 2, pi / 2).doit() == -sqrt(6) / 4 assert Rotation.D(S(3) / 2, S(1) / 2, S(1) / 2, pi / 2, pi / 2, pi / 2).doit() == I * sqrt(2) / 4 assert Rotation.D(S(3) / 2, S(1) / 2, -S(1) / 2, pi / 2, pi / 2, pi / 2).doit() == -sqrt(2) / 4 assert Rotation.D(S(3) / 2, S(1) / 2, -S(3) / 2, pi / 2, pi / 2, pi / 2).doit() == I * sqrt(6) / 4 assert Rotation.D(S(3) / 2, -S(1) / 2, S(3) / 2, pi / 2, pi / 2, pi / 2).doit() == -I * sqrt(6) / 4 assert Rotation.D(S(3) / 2, -S(1) / 2, S(1) / 2, pi / 2, pi / 2, pi / 2).doit() == sqrt(2) / 4 assert Rotation.D(S(3) / 2, -S(1) / 2, -S(1) / 2, pi / 2, pi / 2, pi / 2).doit() == -I * sqrt(2) / 4 assert Rotation.D(S(3) / 2, -S(1) / 2, -S(3) / 2, pi / 2, pi / 2, pi / 2).doit() == sqrt(6) / 4 assert Rotation.D(S(3) / 2, -S(3) / 2, S(3) / 2, pi / 2, pi / 2, pi / 2).doit() == sqrt(2) / 4 assert Rotation.D(S(3) / 2, -S(3) / 2, S(1) / 2, pi / 2, pi / 2, pi / 2).doit() == I * sqrt(6) / 4 assert Rotation.D(S(3) / 2, -S(3) / 2, -S(1) / 2, pi / 2, pi / 2, pi / 2).doit() == -sqrt(6) / 4 assert Rotation.D(S(3) / 2, -S(3) / 2, -S(3) / 2, pi / 2, pi / 2, pi / 2).doit() == -I * sqrt(2) / 4 # j = 2 assert Rotation.D(2, 2, 2, pi / 2, pi / 2, pi / 2).doit() == 1 / 4 assert Rotation.D(2, 2, 1, pi / 2, pi / 2, pi / 2).doit() == -I / 2 assert Rotation.D(2, 2, 0, pi / 2, pi / 2, pi / 2).doit() == -sqrt(6) / 4 assert Rotation.D(2, 2, -1, pi / 2, pi / 2, pi / 2).doit() == I / 2 assert Rotation.D(2, 2, -2, pi / 2, pi / 2, pi / 2).doit() == 1 / 4 assert Rotation.D(2, 1, 2, pi / 2, pi / 2, pi / 2).doit() == I / 2 assert Rotation.D(2, 1, 1, pi / 2, pi / 2, pi / 2).doit() == 1 / 2 assert Rotation.D(2, 1, 0, pi / 2, pi / 2, pi / 2).doit() == 0 assert Rotation.D(2, 1, -1, pi / 2, pi / 2, pi / 2).doit() == 1 / 2 assert Rotation.D(2, 1, -2, pi / 2, pi / 2, pi / 2).doit() == -I / 2 assert Rotation.D(2, 0, 2, pi / 2, pi / 2, pi / 2).doit() == -sqrt(6) / 4 assert Rotation.D(2, 0, 1, pi / 2, pi / 2, pi / 2).doit() == 0 assert Rotation.D(2, 0, 0, pi / 2, pi / 2, pi / 2).doit() == -1 / 2 assert Rotation.D(2, 0, -1, pi / 2, pi / 2, pi / 2).doit() == 0 assert Rotation.D(2, 0, -2, pi / 2, pi / 2, pi / 2).doit() == -sqrt(6) / 4 assert Rotation.D(2, -1, 2, pi / 2, pi / 2, pi / 2).doit() == -I / 2 assert Rotation.D(2, -1, 1, pi / 2, pi / 2, pi / 2).doit() == 1 / 2 assert Rotation.D(2, -1, 0, pi / 2, pi / 2, pi / 2).doit() == 0 assert Rotation.D(2, -1, -1, pi / 2, pi / 2, pi / 2).doit() == 1 / 2 assert Rotation.D(2, -1, -2, pi / 2, pi / 2, pi / 2).doit() == I / 2 assert Rotation.D(2, -2, 2, pi / 2, pi / 2, pi / 2).doit() == 1 / 4 assert Rotation.D(2, -2, 1, pi / 2, pi / 2, pi / 2).doit() == I / 2 assert Rotation.D(2, -2, 0, pi / 2, pi / 2, pi / 2).doit() == -sqrt(6) / 4 assert Rotation.D(2, -2, -1, pi / 2, pi / 2, pi / 2).doit() == -I / 2 assert Rotation.D(2, -2, -2, pi / 2, pi / 2, pi / 2).doit() == 1 / 4
# -*- coding: utf-8 -*- """ Created on Thu Nov 28 09:39:23 2019 @author: Benjamin Smith """ from sympy.physics.quantum.spin import Rotation as r import sympy as sp import numpy as np a, b, c = sp.symbols('a b c') J = 1 Jmag = int(2 * J + 1) alpha, beta, gamma = 0, -np.pi / 2, 0 mat = sp.zeros(Jmag, Jmag) states = np.linspace(-J, J, Jmag, dtype=int) for i in range(Jmag): for j in range(Jmag): mat[i, j] = sp.nsimplify(r.D(J, states[i], states[j], a, b, c).doit(), tolerance=1e-10, rational=True) #rot_mat = mat * sp.Matrix([0, 1, 0]) print(mat)
import numpy as np from sympy.physics.quantum.spin import Rotation as R import sympy as sp sp.init_printing() from matplotlib import pyplot as plt alpha, beta, gamma = sp.symbols('alpha beta gamma') J = 1 m = 1 mp = 1 Rot = sp.zeros(3, 3) for i, m in enumerate(range(-1, 2)): for j, mp in enumerate(range(-1, 2)): val = R.D(J, m, mp, alpha, beta, gamma).doit() Rot[i, j] = val # print(val) ## For sigma light rotated along the polar angle N = 101 angles = np.linspace(0, 2 * np.pi, N) states = np.zeros((N, 3)) #might have to be complex state_init = np.array([[1, 0, 0]]).T for i, ang in enumerate(angles): rotMat = Rot.subs(alpha, 0).subs(gamma, 0).subs(beta, ang) newval = rotMat * state_init states[i, :] = newval.T degrees = angles * 180 / np.pi plt.figure()
for lam2 in [-S(1) / 2, S(1) / 2]: lam_l = lam2 - lam1 for lam in [1]: coeffs += [ Symbol('A_' + str(J_L) + '_' + str(lam) + '_' + str(lam1) + '_' + str(lam2), real=True) ] phases += [ Symbol('d_' + str(J_L) + '_' + str(lam) + '_' + str(lam1) + '_' + str(lam2), real=True) ] A = coeffs[-1] '''A = coeffs[-1] * exp(I*phases[-1])''' B = Rotation.D(J_K, lam, 0, 0, thetaK, 0) C = Rotation.D(J_L, lam, lam_l, phi, thetaL, -phi) amp += A * B * C print print amp.doit() print amp1 = amp.doit().expand(complex=True) amp1_st = amp.doit().expand(complex=True).conjugate() amp_sq = amp1 * amp1_st print simplify(amp_sq.expand()) ''' print amp1 print print amp1_st print