def example1():
#
np.random.seed(47117)
nTry = 1000 #: number of tries
nLayer = 5 #: number of detector layers
print " Gbltst $Rev$ ", nTry, nLayer
start = time.clock()
# track direction
sinLambda = 0.3
cosLambda = math.sqrt(1.0 - sinLambda**2)
sinPhi = 0.
cosPhi = math.sqrt(1.0 - sinPhi**2)
# Curvilinear system: track direction T, U = Z x T / |Z x T|, V = T x U
tuvDir = np.array([[cosLambda * cosPhi, cosLambda * sinPhi, sinLambda], \
[-sinPhi, cosPhi, 0.], \
[-sinLambda * cosPhi, -sinLambda * sinPhi, cosLambda]])
# measurement resolution
measErr = np.array([0.001, 0.001]) # 10 mu
measPrec = 1.0 / measErr**2
# scattering error
scatErr = 0.001 # 1 mrad
# RMS of CurviLinear track parameters (Q/P, slopes, offsets)
clErr = np.array([0.001, -0.1, 0.2, -0.15, 0.25])
# precision matrix for external seed (in local system)
locSeed = None
seedLabel = 0 # label of point with seed
if seedLabel != 0:
print " external seed at label ", seedLabel
#
bfac = 0.2998 # Bz*c for Bz=1
step = 1.5 / cosLambda # constant steps in RPhi
#
Chi2Sum = 0.
NdfSum = 0
LostSum = 0.
#
binaryFile = open("milleBinaryISN.dat", "wb")
#
for iTry in range(nTry):
# generate (CurviLinear) track parameters
clNorm = np.random.normal(0., 1., 5)
clPar = clErr * clNorm
# covariance matrix
clCov = np.eye(5)
for i in range(5):
clCov[i, i] = clErr[i]**2
# arclength
s = 0.
# point-to-point jacobian (from previous point)
jacPointToPoint = np.eye(5)
# additional (local or global) derivatives
addDer = np.array([[1.0], [0.0]])
labGlobal = np.array([[4711], [4711]])
# create trajectory
traj = GblTrajectory(bfac != 0.)
# at previous point: transformation from local to curvilinear system
oldL2c = np.eye(5)
for iLayer in range(nLayer):
#print " layer ", iLayer
# measurement directions (J,K) from stereo angle
sinStereo = (0. if iLayer % 2 == 0 else 0.1)
cosStereo = math.sqrt(1.0 - sinStereo**2)
# measurement system: I, J ,K
ijkDir = np.array([[1., 0., 0.], \
[0., cosStereo, sinStereo], \
[0., -sinStereo, cosStereo]])
# local system: measurement or curvilinear
#local = gblMeasSystem(ijkDir, tuvDir)
local = gblCurviSystem(ijkDir, tuvDir)
# projections
proL2m = local.getTransLocalToMeas()
proL2c = local.getTransLocalToCurvi()
proC2l = np.linalg.inv(proL2c)
# projection curvilinear to measurement directions
proC2m = local.getTransCurviToMeas()
# measurement - prediction in measurement system with error
measNorm = np.random.normal(0., 1., 2)
meas = np.dot(proC2m, clPar[3:5]) + measErr * measNorm
# jacobian is calculated in curvilinear system and transformed
jac = np.dot(proC2l, np.dot(jacPointToPoint, oldL2c))
# point with (independent) measurements (in measurement system)
point = GblPoint(jac)
point.addMeasurement([proL2m, meas, measPrec])
# additional local parameters?
# point.addLocals(addDer)
# additional global parameters?
point.addGlobals(labGlobal, addDer)
addDer = -addDer # locDer flips sign every measurement
# add point to trajectory
iLabel = traj.addPoint(point)
if iLabel == abs(seedLabel):
clSeed = np.linalg.inv(clCov)
locSeed = np.dot(proL2c, np.dot(clSeed, proL2c.T))
# propagate to scatterer
jacPointToPoint = gblSimpleJacobian(step, cosLambda, bfac)
clPar = np.dot(jacPointToPoint, clPar)
clCov = np.dot(jacPointToPoint, np.dot(clCov, jacPointToPoint.T))
s += step
if (iLayer < nLayer - 1):
scat = np.array([0., 0.])
# point with scatterer
jac = np.dot(proC2l, np.dot(jacPointToPoint, proL2c))
point = GblPoint(jac)
if scatErr > 0:
scatP = local.getScatPrecision(scatErr)
point.addScatterer([scat, scatP])
iLabel = traj.addPoint(point)
if iLabel == abs(seedLabel):
clSeed = np.linalg.inv(clCov)
locSeed = np.dot(proL2c, np.dot(clSeed, proL2c.T))
# scatter a little
scatNorm = np.random.normal(0., 1., 2)
clPar[1:3] = clPar[1:3] + scatErr * scatNorm
# propagate to next measurement layer
clPar = np.dot(jacPointToPoint, clPar)
clCov = np.dot(jacPointToPoint, np.dot(clCov,
jacPointToPoint.T))
s += step
oldL2c = proL2c
# add external seed
if locSeed is not None:
traj.addExternalSeed(seedLabel, locSeed)
# fit trajectory
Chi2, Ndf, Lost = traj.fit()
print " Record, Chi2, Ndf, Lost", iTry, Chi2, Ndf, Lost
# dump trajectory
#traj.printPoints()
#traj.printData()
# write to MP binary file
# traj.milleOut(binaryFile)
# sum up
Chi2Sum += Chi2
NdfSum += Ndf
LostSum += Lost
# get corrections and covariance matrix at points
if (iTry == 0):
for i in range(1, nLayer + 1):
locPar, locCov = traj.getResults(-i)
print " >Point ", i
print " locPar ", locPar
#print " locCov ", locCov
locPar, locCov = traj.getResults(i)
print " Point> ", i
print " locPar ", locPar
#print " locCov ", locCov
# check residuals
for i in range(traj.getNumPoints()):
numData, aResiduals, aMeasErr, aResErr, aDownWeight = traj.getMeasResults(
i + 1)
for j in range(numData):
print " measRes ", i, j, aResiduals[j], aMeasErr[
j], aResErr[j], aDownWeight[j]
numData, aResiduals, aMeasErr, aResErr, aDownWeight = traj.getScatResults(
i + 1)
for j in range(numData):
print " scatRes ", i, j, aResiduals[j], aMeasErr[
j], aResErr[j], aDownWeight[j]
#
end = time.clock()
print " Time [s] ", end - start
print " Chi2Sum/NdfSum ", Chi2Sum / NdfSum
print " LostSum/nTry ", LostSum / nTry
