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 Sp3RxU2ReducedIrrep(s, S, Nmax):
""""
Constructs a canonically sorted list of Sp(3,R)xSU(3) states up to Nmax
for given irrep s, sorts by w, n, r
Args:
s: symplectic bandhead (U3State)
S: spin (int)
Returns:
[state1,state2 etc]
"""
## initializing list
states = []
## generating dictionary of all possible raising polynomial labels
## dictionary of form {N:[n1,n2,..]}
PolyDict = u3boson.poly(Nmax)
## iterating over N from 0 to Nmax
for N in range(0, Nmax + 1, 2):
## initialize list
wnset = {}
## selecting polynomial labels for each N
polylist = PolyDict[N]
## order polynomial labels cannonically
polylist_canonical = u3.canonical_sort(polylist)
## iterating over n in polylist
for n in polylist_canonical:
## coupling raising polynomials to bandhead
CoupledDict = u3.couple(s, n)
## iterating over generated list of (lbda,mu)
#wlist_canonical=u3.canonical_sort(CoupledDict.keys())
for lambdamu in CoupledDict:
## converting from SU(2) to U(3)
w = U3State(s.N + N, lambdamu)
## number of times w occurs in kronecker product sxn
rmax = CoupledDict[lambdamu]
## iterating over occurances of w
if w not in wnset:
wnset[w] = []
wnset[w].append((n, rmax))
w_canonical = u3.canonical_sort(wnset.keys())
for w in w_canonical:
nrset = wnset[w]
for n, rmax in nrset:
for r in range(1, rmax + 1):
## appending SpxU2 state to state list
state = SpU2StateRed(SpStateReduced(s, n, r, w), S)
states.append(state)
return states
def Sp_irrep_red(s, Nmax):
"""
constructs a dictioanry of symplectic reduced states sorted according to excitation Nn
currently just for s.three()>3 but will generalize soon
returns dictionary of the form {N:[state1, state2...]}
"""
StateDict = {}
#checking that s is valid unitary U(3) label to serve as bandhead
if Sp_bandhead_check(s):
PolyDict = u3boson.poly(Nmax)
for N in range(0, Nmax + 1, 2):
polylist = PolyDict[N]
states = []
for n in polylist:
CoupledDict = u3.couple(s, n)
for lambdamu in CoupledDict:
w = U3State(s.N + N, lambdamu)
rmax = CoupledDict[lambdamu]
for r in range(1, rmax + 1):
states.append(SpStateReduced(s, n, r, w))
StateDict[N] = states
else:
print "invalid bandhead"
return StateDict
#############################################################################
global Kdictionary
Kdictionary = {}
global Sdictionary
Sdictionary = {}
global SAdictionary
SAdictionary = {}
global S2dictionary
S2dictionary = {}
global Kdic
Kdic = {}
global KAdictionary
KAdictionary = {}
global Poly
Poly = u3boson.poly(20)
global Pdic
Pdic = {}
#############################################################################
def omega(n, w):
"""
Calculates Omega(n,w)
Args:
n is the symplectic multiplicity (class U3State)
w is the symplectic weight (class U3State)
Returns:
Omega (float). For example: