def Sp3RxU4Irrep(s, S, J, Nmax):
"""
Generates list of states in irrep (s,S) up to Nmax for SxL->J
Returns:
statelist: list of states (SpU2StateJ)
"""
## initializing list of states
statelist = []
##The isospin symmetry is determined by the constraint (J+T)%2=1
T = (J + 1) % 2
## generate list of reduced states
redStateList = Sp3RxU4ReducedIrrep(s, S, T, Nmax)
## iterating over reduced states
for redState in redStateList:
## extracting SpStateReduced state and Spin
stateSp = redState.sp
S = redState.S
T = redState.T
## branch to L
Lkset = so3.branching_so3(stateSp.w)
## sorting L's from smallest to largest
Lset = sorted(Lkset.keys())
## iterating over L
for L in Lset:
if so3.mult(S, L, J) == 0:
continue
if (L + S + T) % 2 == 0:
continue
kmax = Lkset[L]
for k in range(1, kmax + 1):
statelist.append(SpU4StateJ(stateSp, k, L, S, J, T))
return statelist
def Sp3RxU2IrrepN(s, S, J, Nmax):
"""
Generates list of states in irrep (s,S) up to Nmax for SxL->J
Returns:
statelist: list of states (SpU2StateJ). List is ordered according to
"""
## initializing list of states
stateNdic = {}
## generate list of reduced states in canonical ordering
redStateList = Sp3RxU2ReducedIrrep(s, S, Nmax)
## iterating over reduced states
for redState in redStateList:
## extracting SpStateReduced state and Spin
stateSp = redState.sp
S = redState.S
## branch to L
Lkset = so3.branching_so3(stateSp.w)
## sorting L's from smallest to largest
Lset = sorted(Lkset.keys())
## iterating over L
for L in Lset:
if so3.mult(S, L, J) == 0:
continue
kmax = Lkset[L]
for k in range(1, kmax + 1):
if stateSp.w.N in stateNdic:
stateNdic[stateSp.w.N] = stateNdic[stateSp.w.N] + [
(SpU2StateJ(stateSp, k, L, S, J))
]
else:
stateNdic[stateSp.w.N] = [SpU2StateJ(stateSp, k, L, S, J)]
return stateNdic
def Sp3RxU2Irrep(s, S, J, Nmax):
"""
Generates list of states in irrep (s,S) up to Nmax for SxL->J
Returns:
statelist: list of states (SpU2StateJ)
"""
## initializing list of states
statelist = []
## generate list of reduced states
redStateList = Sp3RxU2ReducedIrrep(s, S, Nmax)
## iterating over reduced states
for redState in redStateList:
## extracting SpStateReduced state and Spin
stateSp = redState.sp
S = redState.S
## branch to L
Lkset = so3.branching_so3(stateSp.w)
## sorting L's from smallest to largest
Lset = sorted(Lkset.keys())
## iterating over L
for L in Lset:
if so3.mult(S, L, J) == 0:
continue
kmax = Lkset[L]
for k in range(1, kmax + 1):
statelist.append(SpU2StateJ(stateSp, k, L, S, J))
return statelist
def irrep_index(s, S, J, Nmax, Nmin=0, indx=0):
"""
constructs the simplectic irrep starting with lowest grade U(3) states s
inputs:
s: Lowest grade U(3) irrep, U3 class
S: Spin, integer or half integer
J: angular momentum: integer or half integer
Nmax: max number of excitations, integer
Nmin: Starting excitation level, integer, optional with defaut Nmin=0
index: Starting indexing number, option, default is indx=0
output:
irrep: Dictionary {N: (n,r,w,k,L)}
index: Dictionary {(n,r,w,k,L):i}
where n: Raising polynomial U3 content, class U3
w: U3 content of states in Sp irrep, class U3
r: Multiplicity index of w in sxn->w, integer>0
k: branching multiplicity SU(3)->SO(3), integer>0
L: Oribtal angular momentum, integer
"""
###initializing dictionarys
irrep = {}
index = {}
SO3branch = {}
i = indx # iterator for indexing the basis states
###intial calculations
#generating raising polynomials
polyset = u3boson.poly(Nmax)
#generating Symplectic basis states and indexing states
for N in range(Nmin, Nmax + 1, 2):
nset = polyset[N] #generating raising polynomails
for n in nset:
wset = u3.couple(s, n)
for lm in wset:
if lm not in SO3branch:
LKset = so3.branching_so3(
lm, S, J, Restrict=True) #SO3branching_J(lm,mu,lset)
SO3branch[lm] = LKset
#generatoring omega and rhomax
else:
LKset = SO3branch[lm]
##########
if LKset != {}:
w = U3State(s.N + N, lm)
rmax = wset[lm]
##generating index for matrix states starting with i=0
for r in range(1, rmax + 1):
for L in LKset:
for k in range(1, LKset[L] + 1):
psi = SpState(s, n, r, w, k, L)
##generating nested dictionary irrep with the form {N:(n,rmax,w,k,L,M)}
if N in irrep:
irrep[N].append(psi)
else:
irrep[N] = [psi]
index[psi] = i
i = i + 1
#print "dim", len(index)
return irrep, index
def Sp3RxU2IrrepNJ(s, S, J, Nmax):
redstatelist = Sp3RxU2ReducedIrrepN(s, S, Nmax)
state_dict = {}
for N in range(0, Nmax + 1, 2):
statelist = []
for redstate in redstatelist[N]:
Lkset = so3.branching_so3(redstate.sp.w)
Lset = Lkset.keys()
Lset.sort()
for L in Lset:
if so3.mult(L, S, J) == 0:
continue
kmax = Lkset[L]
for k in range(1, kmax + 1):
state = SpU2StateJ(redstate.sp, k, L, S, J)
statelist.append(state)
state_dict[N] = statelist
return state_dict
"""
lm = w.su3
matrix = 1. / 9. * (lm.su3.lbda - lm.su3.mu) * (
lm.su3.lbda + 2 * lm.su3.mu + 3) * (2 * lm.su3.lbda + lm.su3.mu + 3)
return matrix
if __name__ == '__main__':
print "casimir3_su3"
w = SU3State(4, 0)
print casimir3_su3(w)
if __name__ == '__main__':
### Checking orthogonality
coupled = 0
w1 = SU3State(4, 0)
w2 = SU3State(0, 2)
L1set = so3.branching_so3(w1)
L2set = so3.branching_so3(w2)
for L1 in L1set:
k1max = L1set[L1]
for L2 in L2set:
k2max = L2set[L2]
for k1 in range(1, k1max + 1):
for k2 in range(1, k2max + 1):
coupled = coupled + W(w1, k1, L1, w2, k2, L2, SU3State(
4, 2), 2, 2, 1) * W(w1, k1, L1, w2, k2, L2,
SU3State(4, 2), 2, 2, 1)
print "coupled", coupled