def exampleHpsTest(inputfile): ''' Read initial fit and points from test file Create trajectory from points, fit and write trajectory to MP-II binary file, get track parameter corrections and covariance matrix at points. Detector arrangement from text file ''' Chi2Sum = 0. NdfSum = 0 LostSum = 0. Bz = -0.5 # full detector -0.491 for test run detector bfac = 0.0002998 * Bz # for Bz in Tesla, momentum in GeV and Radius in mm np.random.seed(47117) binaryFile = open("milleBinaryISN.dat", "wb") inputFile = open(inputfile, 'r') events = utils.readHPSEvents(inputFile, nEventsMax) print 'Read %d events from file' % len(events) #print " GblHpsTest $Rev: 234 $ ", nTry, nLayer nTry = 0 start = time.clock() h_chi2prob_gbl_truth = TH1F('h_chi2prob_gbl_truth','h_chi2prob_gbl_truth',50,0,1) h_chi2prob_initial_truth = TH1F('h_chi2prob_initial_truth','h_chi2prob_initial_truth',50,0,1) for event in events: if debug: print '\nEvent %d has %d tracks ' % (event.id, len(event.tracks)) for track in event.tracks: if debug: print '\nProcessing track %d \n p = %.3f p(truth)=%.3f' % (track.id, track.p(bfac), track.p_truth(bfac)) # if there's no truth info -> skip it if track.p_truth(bfac) == 0.: print 'No truth info, skip track %d in event %d ' % (track.id, event.id) continue traj = GblTrajectory(True) #print " perPar ", track.perParTruth # hlxPar = [ cmp(bfac, 0.) * track.curvature(), track.phi0(), track.d0(), track.slope(), track.z0()] hlxPar = [ cmp(bfac, 0.) * track.curvature(), track.phi0(), -track.d0(), track.slope(), track.z0()] #hlxPar = [ cmp(bfac, 0.) * track.curvature_truth(), track.phi0_truth(), track.d0_truth(), track.slope_truth(), track.z0_truth()] #print " hlxPar ", hlxPar hlx = SimpleHelix(hlxPar) cosLambda = hlx.getZSDirection()[0] # stupid error for now #clCov = np.eye(5) #for i in range(5): # clCov[i, i] = clErr[i] ** 2 #clCov = track.clCov stripLabelMap = {} if debug: print 'Track has %d strip clusters' % len(track.strips) # arc length s = 0. # point-to-point jacobian (from previous point) jacPointToPoint = np.eye(5) #start trajectory at reference point (defining s=0) point = GblPoint(jacPointToPoint) refLabel = traj.addPoint(point) # multiple scattering covariance matrix (for curvilinear track parameters) msCov = np.zeros((5, 5)) # store projection for later use proM2l_list = {} proL2m_list = {} for strip in track.strips: if debug: print '\nProcessing strip %d at layer %d ' % (strip.id, strip.layer) # direction in detector plane in XY: (xDir, yDir, 0.) xDir = -strip.w[1] yDir = strip.w[0] # direction in detector plane in Z: (0., 0., 1.) # position of detector (center) xDet = strip.origin[0] yDet = strip.origin[1] zDet = strip.origin[2] # get prediction along the 2 directions (in the detector plane) pred = hlx.getExpectedPlanePos(xDet, yDet, xDir, yDir, zDet) if pred is None: continue # no intersection of track and detector # prediction position (in global system) xPred = xDet + pred[0] * xDir yPred = yDet + pred[0] * yDir zPred = zDet + pred[1] # project onto u-direction uPred = pred[0] * (xDir * strip.u[0] + yDir * strip.u[1]) + pred[1] * strip.u[2] # stupid iterative intercept predIter = utils.getXPlanePositionIterative(track.perPar,strip.origin,strip.w,1.0e-8) diffIter = predIter - strip.origin uPredIter = np.dot(strip.u , diffIter.T ) #xPred = predIter[0] #yPred = predIter[1] #zPred = predIter[2] #pred0 = (predIter[0] - xDet) / xDir #pred1 = (predIter[1] - zDet) #uPredIter = pred0 * (xDir * strip.u[0] + yDir * strip.u[1]) + pred1 * strip.u[2] # u residuum uRes = strip.meas - uPred uResIter = strip.meas - uPredIter #uRes = uResIter # (3D) arc-length sArc = pred[3] / cosLambda phi = pred[4] #print " pred ", sArc, xPred, yPred, zPred if nTry == 0: print " uRes ",strip.id, ' uRes ', uRes, ' pred ', xPred, yPred, zPred, ' s(3D) ', sArc #print " uRes ", strip.id, 'uRes(Cl) ', uRes, ' uRes ', strip.ures, ' uResIter ', uResIter, ' pred ', xPred, yPred, zPred, ' predIter ', predIter, ' s(3D) ', sArc #print -1*track.d0(),track.z0(),track.phi0(),track.slope(),track.curvature() #print predIter, diffIter, strip.u, uPredIter, strip.meas #print " uRes ", strip.id, uRes, uResIter, strip.ures, strip.ures_err, ' pred ', xPred, yPred, zPred, ' s ', pred[3], ' s3D ', sArc, ' on plane ', np.dot(np.array([[xPred, yPred, zPred]]) - strip.origin , np.array([strip.w]).T ) #print ' predIter ', predIter #print ' predIter diff ', (np.array([xPred,yPred,zPred]) - predIter) #print " java ", strip.id , strip.ures, ' pred ', strip.tPos, ' on plane ', np.dot(np.array([strip.tPos]) - strip.origin , np.array([strip.w]).T ) step = sArc - s if debug: print 'Step %f (s %f pathLen %f)' % (step, s, sArc) # measurement direction(s): (m[0]=u, m[1]=v) if debug: print 'Strip udir', strip.u if debug: print 'Strip vdir', strip.v mDir = np.array([strip.u, strip.v]) if debug: print 'mDir:\n', mDir # track direction: in x directon sinLambda = strip.sinLambda cosLambda = math.sqrt(1.0 - sinLambda ** 2) sinPhi = strip.sinPhi cosPhi = math.sqrt(1.0 - sinPhi ** 2) if debug: print 'Track direction sinLambda=%f sinPhi=%f' % (sinLambda, sinPhi) # tDir = np.array([cosLambda * cosPhi, cosLambda * sinPhi, sinLambda]) # U = Z x T / |Z x T|, V = T x U uvDir = np.array([[-sinPhi, cosPhi, 0.], \ [-sinLambda * cosPhi, -sinLambda * sinPhi, cosLambda]]) # projection measurement to local (curvilinear uv) directions (duv/dm) proM2l = np.dot(uvDir, mDir.T) proM2l_list[strip.id] = proM2l if debug: print 'proM2l:\n', proM2l # projection local (uv) to measurement directions (dm/duv) proL2m = np.linalg.inv(proM2l) proL2m_list[strip.id] = proL2m if debug: print 'proL2m:\n', proL2m # measurement/residual in the measurement system #meas = np.array([strip.ures, 0.]) meas = np.array([uRes, 0.]) #meas[0] += deltaU[iLayer] # misalignment measErr = np.array([strip.ures_err, strip.ures_err]) measPrec = 1.0 / measErr ** 2 measPrec[1] = 0. # 1D measurement perpendicular to strip direction if debug: print 'meas ', meas, ' measErr ', measErr, ' measPrec ', measPrec #propagate to this strip #jacPointToPoint = utils.gblSimpleJacobianLambdaPhi(step, cosLambda, bfac) jacPointToPoint = hlx.getPropagatorSimple(step, abs(bfac)) #print jacPointToPoint point = GblPoint(jacPointToPoint) if debug: print 'jacPointToPoint to extrapolate to this point:' print point.getP2pJacobian() #propagate MS covariance matrix msCov = np.dot(jacPointToPoint, np.dot(msCov, jacPointToPoint.T)) # MS covariance for measurements measMsCov = np.dot(proL2m, np.dot(msCov[3:, 3:], proL2m.T)) if debug: print " uPred ", strip.id, pred[3], uPred, strip.meas, strip.ures, strip.ures_err, measMsCov[0, 0] #plots.h_measMsCov.Fill(float(strip.layer),measMsCov[0,0]) if debug: print 'msCov propagated to this point:' print msCov print 'measMsCov at this point to be used in measPrec:' print measMsCov if useUncorrMS: # blow up measurement errors according to multiple scattering measPrec[0] = 1.0 / (measErr[0] ** 2 + measMsCov[0, 0]) point.addMeasurement([proL2m, meas, measPrec]) if debug: print 'measMsCov ', measMsCov[0, 0] scat = np.array([0., 0.]) scatErr = np.array([ strip.scatAngle, strip.scatAngle / cosLambda]) scatPrec = 1.0 / scatErr ** 2 if not useUncorrMS: point.addScatterer([scat, scatPrec]) #update MS covariance matrix msCov[1, 1] += scatErr[0] ** 2; msCov[2, 2] += scatErr[1] ** 2 if debug: print 'adding scatError to the msCov from this point:' print scatErr addDer = np.array([[1.0], [0.0]]) #top or bottom half if math.copysign(1, sinLambda) > 0: offset = 11101 else: offset = 21101 labGlobal = np.array([[offset + strip.layer], [0]]) point.addGlobals(labGlobal, addDer) # add point to trajectory iLabel = traj.addPoint(point) s += step stripLabelMap[strip] = iLabel if debug: print 'Do the fit' Chi2, Ndf, Lost = traj.fit() # write to millepede traj.milleOut(binaryFile) # sum up Chi2Sum += Chi2 NdfSum += Ndf LostSum += Lost # get corrections and covariance matrix at points result = utils.GBLResults(track) #traj.dump() if nTry == 0: print 'fit result: Chi2=%f Ndf=%d Lost=%d' % (Chi2, Ndf, Lost) print 'get corrections and covariance matrix for %d points:' % 1 #traj.getNumPoints() for i in range(1, traj.getNumPoints() + 1): # label start at 1 locPar, locCov = traj.getResults(-i) if nTry < 0: print " >Point ", i print " locPar ", locPar #print " locCov ", locCov result.addPoint(-i, locPar, locCov) locPar, locCov = traj.getResults(i) if nTry < 0: print " Point> ", i print " locPar ", locPar #print " locCov ", locCov result.addPoint(i, locPar, locCov) # calculate the truth chi2 from initial fit # get the truth and fitted params with indexes same as cov matrix of initial fit (dca,phi0,curv,z0,slope) perParVec = np.array([track.d0(), track.phi0(), track.curvature(), track.z0(), track.slope()]) perParVecTruth = np.array([track.d0_truth(), track.phi0_truth(), track.curvature_truth(), track.z0_truth(), track.slope_truth()]) perParVecRes = perParVec - perParVecTruth chi2_initial_truth = np.dot(perParVecRes, np.dot(np.linalg.inv(track.perCov) , perParVecRes)) # calculate the truth chi2 from gbl fit at vertex clParVtx = np.array(track.clPar) + np.array(result.locPar[1]) clParTruth = np.array(track.clParTruth) clParRes = clParVtx - clParTruth chi2_gbl_truth = np.dot(clParRes, np.dot(np.linalg.inv(result.locCov[1]), clParRes)) #print " truth ", track.clParTruth #print " res ", refLabel, result.locPar[refLabel], result.locCov[refLabel] # calculate chi2 for seeding by truth label = 1#refLabel chi2_res = np.dot(result.locPar[label], np.dot(np.linalg.inv(result.locCov[label]), result.locPar[label])) #chi2_res4 = np.dot(result.locPar[label][:4], np.dot(np.linalg.inv(result.locCov[label][:4, :4]), result.locPar[label][:4])) print " Chi2: ", #for i in range(5): # print track.clParTruth[i], result.locPar[label][i] / math.sqrt(result.locCov[label][i][i]), print event.id, chi2_res, chi2_gbl_truth, chi2_initial_truth #print clParRes #print track.clPar #print result.locPar[1] #print clParVtx #print clParTruth #print result.locCov[label] h_chi2prob_gbl_truth.Fill(TMath.Prob(chi2_gbl_truth,5)) h_chi2prob_initial_truth.Fill(TMath.Prob(chi2_initial_truth,5)) ''' print " clPar ", track.clPar print " clParTruth ", track.clParTruth print " clParVtx ", clParVtx print " clParRes ", clParRes print " res[1] ", np.array(result.locPar[1]) print " cov[1] ", result.locCov[1] ''' ''' # plots plots.h_clPar_xT.Fill(track.clPar[3]) plots.h_clPar_yT.Fill(track.clPar[4]) plots.h_clPar_qOverP.Fill(track.clPar[0]) plots.h_clPar_lambda.Fill(track.clPar[1]) # transform phi to plot nicer if track.clPar[2]<math.pi: plots.h_clPar_phi.Fill(track.clPar[2]) else: plots.h_clPar_phi.Fill(track.clPar[2]-math.pi*2) plots.h_clPar_res_qOverP.Fill(clParRes[0,0]) plots.h_clPar_res_lambda.Fill(clParRes[0,1]) plots.h_clPar_res_phi.Fill(clParRes[0,2]) plots.h_clPar_res_xT.Fill(clParRes[0,3]) plots.h_clPar_res_yT.Fill(clParRes[0,4]) plots.h_clPar_pull_qOverP.Fill(clParRes[0,0]/math.sqrt(result.locCov[1][0,0])) plots.h_clPar_pull_lambda.Fill(clParRes[0,1]/math.sqrt(result.locCov[1][1,1])) plots.h_clPar_pull_phi.Fill(clParRes[0,2]/math.sqrt(result.locCov[1][2,2])) plots.h_clPar_pull_xT.Fill(clParRes[0,3]/math.sqrt(result.locCov[1][3,3])) plots.h_clPar_pull_yT.Fill(clParRes[0,4]/math.sqrt(result.locCov[1][4,4])) plots.h_perPar_res_d0.Fill(perParVecRes[0,0]) plots.h_perPar_res_phi0.Fill(perParVecRes[0,1]) plots.h_perPar_res_kappa.Fill(perParVecRes[0,2]) plots.h_perPar_res_z0.Fill(perParVecRes[0,3]) plots.h_perPar_res_slope.Fill(perParVecRes[0,4]) plots.h_chi2_initial.Fill(track.chi2Initial) plots.h_chi2ndf_initial.Fill(track.chi2Initial/track.ndfInitial) plots.h_chi2_initial_truth.Fill(chi2_initial_truth) plots.h_chi2ndf_initial_truth.Fill(chi2_initial_truth/5.0) plots.h_chi2prob_initial_truth.Fill(utils.chi2Prob(chi2_initial_truth,5)) plots.h_chi2_gbl_truth.Fill(chi2_gbl_truth) plots.h_chi2ndf_gbl_truth.Fill(chi2_gbl_truth/5.0) plots.h_chi2prob_gbl_truth.Fill(utils.chi2Prob(chi2_gbl_truth,5)) plots.h_chi2.Fill(Chi2) plots.h_chi2ndf.Fill(Chi2/Ndf) plots.h_p.Fill(track.p(bfac)) plots.h_qOverP.Fill(track.qOverP(bfac)) plots.h_qOverP_truth_res.Fill(track.qOverP(bfac) - track.q()/track.p_truth(bfac)) plots.h_p_truth.Fill(track.p_truth(bfac)) plots.h_p_truth_res.Fill(track.p(bfac)-track.p_truth(bfac)) plots.h_qOverP_corr.Fill(result.qOverPCorr()) plots.h_qOverP_gbl.Fill(result.qOverP_gbl(bfac)) plots.h_qOverP_truth_res_gbl.Fill(result.qOverP_gbl(bfac) - result.track.q()/result.track.p_truth(bfac)) plots.h_p_corr.Fill(result.pCorr(bfac)) plots.h_p_gbl.Fill(result.p_gbl(bfac)) plots.h_p_truth_res_gbl.Fill(result.p_gbl(bfac) - result.track.p_truth(bfac)) vtx_idx = 1 # first point is at s=0 (the "vtx" is at -670mm in test run) plots.h_vtx_xT_corr.Fill(result.xTCorr(vtx_idx)) plots.h_vtx_yT_corr.Fill(result.yTCorr(vtx_idx)) plots.h_d0_corr.Fill(result.d0Corr(vtx_idx)) plots.h_z0_corr.Fill(result.z0Corr(vtx_idx)) plots.h_d0.Fill(track.d0()) plots.h_z0.Fill(track.z0()) plots.h_d0_gbl.Fill(result.d0_gbl(vtx_idx)) plots.h_z0_gbl.Fill(result.z0_gbl(vtx_idx)) for label,corr in result.locPar.iteritems(): if label>0: lbl = 2*(label-1) + 1 else: lbl = -1*2*label plots.h_xT_corr.Fill(lbl, corr[result.idx_xT]) plots.h_yT_corr.Fill(lbl, corr[result.idx_yT]) for istrip in range(len(track.strips)): strip = track.strips[istrip] # find the label, if not found it's the vertex if strip in stripLabelMap: iLabel = stripLabelMap[strip] else: iLabel = 1 #residuals plots.h_res_layer.Fill(strip.layer,strip.ures) # correction to xT,yT from GBL fit corr = np.matrix( [result.locPar[iLabel][3], result.locPar[iLabel][4] ] ) # project to measurement direction corr_meas = np.matrix( proL2m_list[strip.id] ) * np.transpose( np.matrix( corr ) ) ures_gbl = strip.ures - corr_meas[0,0] # note minus sign due to definition of residual plots.h_res_gbl_layer.Fill(strip.layer,ures_gbl) # make plots for a given track only if nTry==0: plots.gr_ures.SetPoint(istrip,strip.pathLen,strip.ures) plots.gr_ures.SetPointError(istrip,0.,strip.ures_err) plots.gr_ures_truth.SetPoint(istrip,strip.pathLen,strip.uresTruth) plots.gr_ures_simhit.SetPoint(istrip,strip.pathLen,strip.uresSimHit) meas = np.array([strip.ures, 0.]) #locRes = np.matrix(proM2l_list[strip.id]) * np.transpose(np.matrix(meas)) #xT_res = locRes[0,0] #yT_res = locRes[1,0] # find corrections to xT and yT plots.gr_corr_ures.SetPoint(istrip, strip.pathLen, corr_meas[0,0]) #u-direction ures_corr = meas - corr_meas.T plots.gr_ures_corr.SetPoint(istrip, strip.pathLen, ures_corr[0,0]) #u-direction ''' nTry += 1 # end = time.clock() print " Processed %d tracks " % nTry print " Time [s] ", end - start print " Chi2Sum/NdfSum ", Chi2Sum / NdfSum print " LostSum/nTry ", LostSum / nTry c = TCanvas('c','c',10,10,700,500) c.Divide(1,2) c.cd(1) h_chi2prob_initial_truth.Draw() c.cd(2) h_chi2prob_gbl_truth.Draw() ans = raw_input('kill...') # '''