def setMBS(self, mbs):
self.mbs = mbs
parity = 1
occPos = 0
empPos = 0
self.occList = []
self.nextEmptyList = []
self.emptyList = []
# Loop through each of the sps's:
for s in xrange(self.nStates):
self.parity[s] = parity # set the parity
if self.mbs & (0x1 << s): # if s is an occupied state
if self.vsList[s]: # if it is a valid state for the operator
self.occList.append(s)
self.nextEmptyList.append(empPos)
occPos = occPos + 1
parity = -parity # if occupied, change the next state parity
elif self.vsList[s]:
self.emptyList.append(s) # mark unoccupied
empPos = empPos + 1
# So, we need to find n = p electrons choose p electron states
# p electrons is nParticles - f electrons
# p states is fixed (well, based on the vsList)
# see discussion in __init__
if self.optStates > 0:
#print self.optStates, occPos
return int(CG.binomialCoeff(self.optStates, self.nParticles - occPos))
else:
return 1
def genFermionStateTable(nFermions):
plist = Plist.AtomicOrbitalPlist()
plist.readPlist()
nStates = plist.aoList.nStates
debugFlag = True
# In real situations, more than 32 states will overflow memory
# But in small situations, this is allowed
if nStates > 32:
print '*** WARNING: *** nStates is larger than 32!! Continuing ... '
# The number of fermions cannot be more than the number of states
if nFermions > nStates:
raise Exception('Number of particles exceeds the number of states! '+str(nFermions)+' '+str(nStates))
return
# The dimension is the total number of many-body states
dim = CG.binomialCoeff(nStates, nFermions)
print '<------------------------ State Table -------------------->'
print 'Fermions = ', nFermions, ' ... States = ', nStates, '... Dimension = ', dim
# Create an empty python dictionary
stateTableDict = dict()
stateTable = []
# initialize the first state
# the low nFermions bits are set to 1
state = Bit.BitStr(nStates)
for ferm in range(nFermions):
state.set(ferm)
# cursor is the position of the highest bit in this group of ones
cursor = nFermions - 1
# ones is the total number of ones in this group of ones
ones = nFermions
# --------------------------------------------------------------------
# Loop through each many-body state
# --------------------------------------------------------------------
for mbState in range(dim):
stateTableDict[state.value] = mbState # set the key & value
stateTable.append(state.value)
if dim == 1:
break
# move the high bit up
state.clear(cursor)
cursor = cursor
state.set(cursor+1)
ones = ones - 1 # decrement the number of ones in the group
if ones > 0:
# --------------------------------------------------------------------
# move all of the lower ones down
# --------------------------------------------------------------------
for sbState in range(cursor):
if sbState < ones:
state.set(sbState)
else:
state.clear(sbState)
# --------------------------------------------------------------------
cursor = ones - 1 # move the cursor to end of group
else: # no more ones in the group
# --------------------------------------------------------------------
# find the next one to move
for sbState in range(cursor+1,nStates):
if not state.get(sbState):
cursor = sbState - 1
break
else:
ones = ones + 1
# --------------------------------------------------------------------
# end for sbState in range(cursor+1,nStates+1):
# --------------------------------------------------------------------
f = open('./stateTable.pkl', 'w')
pickle.dump(stateTable, f)
f.close()
f = open('./stateTableDict.pkl','w')
pickle.dump(stateTableDict, f)
f.close()
del stateTable
del stateTableDict
# --------------------------------------------------------------------
# Dump out the table for debugging
# --------------------------------------------------------------------
if debugFlag:
# Read in the state table pickles
f = open('stateTable.pkl', 'r')
dbgStateTable = pickle.load(f)
f.close()
f = open('stateTableDict.pkl', 'r')
dbgStateTableDict = pickle.load(f)
f.close()
for rStateIndex, rState in enumerate(dbgStateTable):
state = Bit.BitStr(nStates, rState)
print 'State %d = %s' % (rStateIndex, state.display())
if rStateIndex != dbgStateTableDict[rState]:
raise Exception('Mismatch between state index and dictionary!'+str(rStateIndex))
f = open('./mbDimension.pkl','w')
pickle.dump(dim, f)
f.close()
f = open('./nParticles.pkl','w')
pickle.dump(nFermions, f)
f.close()
print '<------------------------ End State Table -------------------->'
print
