makeMuonMisalignmentScenario Namespace Reference

Functions
def	cholesky
def	mmult
	Print out user's choices as diagnostics. More...
def	mtrans
def	mvdot
def	random6dof
	Generate correlated random misalignments for all chambers. More...

Variables
tuple	ave_phix = sum_phix/float(len(misal))
tuple	ave_phixphix = sum_phixphix/float(len(misal))
tuple	ave_phixphiy = sum_phixphiy/float(len(misal))
tuple	ave_phixphiz = sum_phixphiz/float(len(misal))
tuple	ave_phiy = sum_phiy/float(len(misal))
tuple	ave_phiyphiy = sum_phiyphiy/float(len(misal))
tuple	ave_phiyphiz = sum_phiyphiz/float(len(misal))
tuple	ave_phiz = sum_phiz/float(len(misal))
tuple	ave_phizphiz = sum_phizphiz/float(len(misal))
tuple	ave_x = sum_x/float(len(misal))
tuple	ave_xphix = sum_xphix/float(len(misal))
tuple	ave_xphiy = sum_xphiy/float(len(misal))
tuple	ave_xphiz = sum_xphiz/float(len(misal))
tuple	ave_xx = sum_xx/float(len(misal))
tuple	ave_xy = sum_xy/float(len(misal))
tuple	ave_xz = sum_xz/float(len(misal))
tuple	ave_y = sum_y/float(len(misal))
tuple	ave_yphix = sum_yphix/float(len(misal))
tuple	ave_yphiy = sum_yphiy/float(len(misal))
tuple	ave_yphiz = sum_yphiz/float(len(misal))
tuple	ave_yy = sum_yy/float(len(misal))
tuple	ave_yz = sum_yz/float(len(misal))
tuple	ave_z = sum_z/float(len(misal))
tuple	ave_zphix = sum_zphix/float(len(misal))
tuple	ave_zphiy = sum_zphiy/float(len(misal))
tuple	ave_zphiz = sum_zphiz/float(len(misal))
tuple	ave_zz = sum_zz/float(len(misal))
tuple	cfgfile = file(outputName + "_convert_cfg.py", "w")
	Convert it to an SQLite file with CMSSW. More...
tuple	chomat = cholesky(matrix)
string	components = "xx"
tuple	globalape = mmult(rot, mmult(localape, mtrans(rot)))
list	globalxx = globalape[0]
list	globalxy = globalape[0]
list	globalxz = globalape[0]
list	globalyy = globalape[1]
list	globalyz = globalape[1]
list	globalzz = globalape[2]
list	localape = [[xx, xy, xz], [xy, yy, yz], [xz, yz, zz]]
list	matrix
dictionary	misal = {}
list	outputName = args[0]
tuple	parser = OptionParser(usage="Usage: python %prog outputName [options] (default is unit matrix times 1e-15)")
	Get variances and covariances from the commandline. More...
list	rot = rotation[system, whendcap, station, ring, sector]
int	sum_phix = 0
int	sum_phixphix = 0
int	sum_phixphiy = 0
int	sum_phixphiz = 0
int	sum_phiy = 0
int	sum_phiyphiy = 0
int	sum_phiyphiz = 0
int	sum_phiz = 0
int	sum_phizphiz = 0
int	sum_x = 0
	More diagnostics. More...
int	sum_xphix = 0
int	sum_xphiy = 0
int	sum_xphiz = 0
int	sum_xx = 0
int	sum_xy = 0
int	sum_xz = 0
int	sum_y = 0
int	sum_yphix = 0
int	sum_yphiy = 0
int	sum_yphiz = 0
int	sum_yy = 0
int	sum_yz = 0
int	sum_z = 0
int	sum_zphix = 0
int	sum_zphiy = 0
int	sum_zphiz = 0
int	sum_zz = 0
tuple	txtfile = file(outputName + "_correlations.txt", "w")
	Delete all three files at once to make sure the user never sees stale data (e.g. More...
tuple	xmlfile = file(outputName + ".xml", "w")
	Make an XML representation of the misalignment. More...

Function Documentation

def makeMuonMisalignmentScenario.cholesky

(

A

)

Cholesky decomposition of the correlation matrix to properly normalize the transformed random deviates

Definition at line 110 of file makeMuonMisalignmentScenario.py.

References mmult(), and mathSSE.sqrt().

def cholesky(A):
    """Cholesky decomposition of the correlation matrix to properly normalize the transformed random deviates"""

    # A = L * D * L^T = (L * D^0.5) * (L * D^0.5)^T where we want (L * D^0.5), the "square root" of A
    # find L and D from A using recurrence relations
    L = {}
    D = {}
    for j in range(len(A[0])):
        D[j] = A[j][j] - sum([L[j,k]**2 * D[k] for k in range(j)])
        for i in range(len(A)):
            if i > j:
                L[i,j] = (A[i][j] - sum([L[i,k] * L[j,k] * D[k] for k in range(j)])) / D[j]

    L = [[    1.,     0.,     0.,     0.,     0., 0.],
         [L[1,0],     1.,     0.,     0.,     0., 0.],
         [L[2,0], L[2,1],     1.,     0.,     0., 0.],
         [L[3,0], L[3,1], L[3,2],     1.,     0., 0.],
         [L[4,0], L[4,1], L[4,2], L[4,1],     1., 0.],
         [L[5,0], L[5,1], L[5,2], L[5,1], L[5,0], 1.]]

    Dsqrt = [[sqrt(D[0]),         0.,          0.,         0.,         0.,         0.],
             [        0., sqrt(D[1]),          0.,         0.,         0.,         0.],
             [        0.,         0., sqrt(D[2]),          0.,         0.,         0.],
             [        0.,         0.,          0., sqrt(D[3]),         0.,         0.],
             [        0.,         0.,          0.,         0., sqrt(D[4]),         0.],
             [        0.,         0.,          0.,         0.,         0., sqrt(D[5])]]

    return mmult(L, Dsqrt)