--- /dev/null
+/*
+ marian.ivanov@cern.ch, Stefan.Rossegger@cern.ch
+
+ Macro to fit alignment/E field distortion maps
+ As a input output cluster distortion maps (produced by AliTPCcalibAling class)
+ are used. Cluster distrotion maps granularity (180 *phi x44 *theta x 53 R)
+
+ In total 440 parameters to fit using global fit:
+
+ 1. Rotation and translation for each sector (72x2)
+ 2. Rotation and translation for each quadrant of OROC (36x4x2)
+ 3. Rod/strip shifts in IFC and OFC (18 sectors x 2 sides x 2 )
+ 4. Rotated clips in IFC and OFC
+
+
+ Input file mean.root with distortion tree expected to be in directory:
+ ../mergeField0/clusterDY.root
+ The ouput file fitRodShift.root contains:
+ 1. Resulting (residual) AliTPCCalibMisalignment and AliTPCFCVoltError3D classes
+ 2. All important temporary results are stored in the workspace (TTreeSRedirector) associated
+ with the file - fitrodShift
+ 2.a Fit parameters with errors
+ 2.b QA default graphs
+ 2.c QA defualt histograms
+
+
+
+ Functions:
+ 1. LoadModels() - load models to fit - Rod shift (10,20)
+ 2. RegisterAlignFunction() - register align functions (10-16)
+ 3. LoadTrees - load trees and make aliases
+ 4. PrintFit - helper function to print substring of the fit
+ 5. DeltaLookup - function to calulate the distortion for given distortion cunction
+ -
+ 6. MakeAliases - Make tree aliases shortcuts for the fitting function
+ //
+ 7. MakeAlignCorrection - Crete alignment entry to be stored in the OCDB
+ - Dump fit parameters and errors
+ 8. MakeQuadrantCorrection -
+ - Dump fit parameters and errors
+
+ 9. FitRodShifts - main minimization function
+
+
+ .x ~/rootlogon.C
+ .x ~/NimStyle.C
+ .L $ALICE_ROOT/TPC/CalibMacros/FitRodShift.C+
+ FitRodShift(kFALSE);
+ //
+
+*/
+
+#if !defined(__CINT__) || defined(__MAKECINT__)
+#include "TFile.h"
+#include "TTreeStream.h"
+#include "TMath.h"
+#include "TGraph.h"
+#include "TRandom.h"
+#include "TTree.h"
+#include "TF1.h"
+#include "TH2F.h"
+#include "TH3F.h"
+#include "TAxis.h"
+#include "TPad.h"
+#include "TCanvas.h"
+#include "TStyle.h"
+#include "AliTPCParamSR.h"
+#include "TDatabasePDG.h"
+#include "AliTPCFCVoltError3D.h"
+#include "AliTPCROCVoltError3D.h"
+#include "AliTPCComposedCorrection.h"
+#include "AliTPCBoundaryVoltError.h"
+#include "AliCDBEntry.h"
+#include "AliTPCROC.h"
+#include <TStatToolkit.h>
+#include "TCut.h"
+#include "TGraphErrors.h"
+#include "AliTPCCalibGlobalMisalignment.h"
+#endif
+
+TTreeSRedirector *pcWorkspace= 0; // Workspace to store the fit parameters and QA histograms
+TTree * treeDY= 0; //distortion tree - Dy
+TTree * treeDZ= 0; //distortion tree - Dz
+// fit models ...
+AliTPCFCVoltError3D *rotOFC =0; // fit models
+AliTPCFCVoltError3D *rodOFC1 =0;
+AliTPCFCVoltError3D *rodOFC2 =0;
+AliTPCFCVoltError3D *rotIFC =0;
+AliTPCFCVoltError3D *rodIFC1 =0;
+AliTPCFCVoltError3D *rodIFC2 =0;
+AliTPCFCVoltError3D *rodAll =0; //all lookup initialized
+//
+AliTPCComposedCorrection *corFit0 = 0; // composed correction
+void FitFunctionQA();
+void MakeQA();
+void DrawAlignParam();
+
+void PrintFit(TString fitString, TString filter){
+ //
+ // helper function to print substring of the fit
+ // TString fitString =*strFitGA;
+ // TString filter="rot";
+ //
+ TObjArray *arr = fitString.Tokenize("++");
+ Int_t entries=arr->GetEntries();
+ for (Int_t i=0; i<entries; i++){
+ TString aaa = arr->At(i)->GetName();
+ if (aaa.Contains(filter)==1){
+ printf("%d\t%s\n",i,aaa.Data());
+ }
+ }
+}
+
+
+void LoadModels(){
+ //
+ // Load the models from the file
+ // Or create it
+ //
+ Int_t volt = 1;
+ TFile f("OCDB-RodShifts.root");
+ AliCDBEntry *entry = (AliCDBEntry*) f.Get("AliCDBEntry");
+ if (entry) { // load file
+ AliTPCComposedCorrection *cor = (AliTPCComposedCorrection*) entry->GetObject();
+ cor->Print();
+ TCollection *iter = cor->GetCorrections();
+ rotOFC = (AliTPCFCVoltError3D*)iter->FindObject("rotOFC");
+ rodOFC1 = (AliTPCFCVoltError3D*)iter->FindObject("rodOFC1");
+ rodOFC2 = (AliTPCFCVoltError3D*)iter->FindObject("rodOFC2");
+ rotIFC = (AliTPCFCVoltError3D*)iter->FindObject("rotIFC");
+ rodIFC1 = (AliTPCFCVoltError3D*)iter->FindObject("rodIFC1");
+ rodIFC2 = (AliTPCFCVoltError3D*)iter->FindObject("rodIFC2");
+ rodAll = (AliTPCFCVoltError3D*)iter->FindObject("rodAll");
+ // rotOFC->CreateHistoDZinXY(1,500,500)->Draw("surf2");
+ } else {
+ // OFC
+ rotOFC = new AliTPCFCVoltError3D();
+ rotOFC->SetOmegaTauT1T2(0,1,1);
+ rotOFC->SetRotatedClipVoltA(1,volt);
+ rotOFC->SetRotatedClipVoltC(1,volt);
+ //
+ rodOFC1 = new AliTPCFCVoltError3D();
+ rodOFC1->SetOmegaTauT1T2(0,1,1);
+ rodOFC1->SetRodVoltShiftA(18,volt);
+ rodOFC1->SetRodVoltShiftC(18,volt);
+ //
+ rodOFC2 = new AliTPCFCVoltError3D();
+ rodOFC2->SetOmegaTauT1T2(0,1,1);
+ rodOFC2->SetCopperRodShiftA(18,volt);
+ rodOFC2->SetCopperRodShiftC(18,volt);
+ // IFC
+ rotIFC = new AliTPCFCVoltError3D();
+ rotIFC->SetOmegaTauT1T2(0,1,1);
+ rotIFC->SetRotatedClipVoltA(0,volt);
+ rotIFC->SetRotatedClipVoltC(0,volt);
+ //
+ rodIFC1 = new AliTPCFCVoltError3D();
+ rodIFC1->SetOmegaTauT1T2(0,1,1);
+ rodIFC1->SetRodVoltShiftA(0,volt);
+ rodIFC1->SetRodVoltShiftC(0,volt);
+ //
+ rodIFC2 = new AliTPCFCVoltError3D();
+ rodIFC2->SetOmegaTauT1T2(0,1,1);
+ rodIFC2->SetCopperRodShiftA(0,volt);
+ rodIFC2->SetCopperRodShiftC(0,volt);
+ // dummy object with all inits
+ rodAll = new AliTPCFCVoltError3D();
+ Double_t volt0=0.0000000001;
+ rodAll->SetRotatedClipVoltA(1,volt0);
+ rodAll->SetRotatedClipVoltC(1,volt0);
+ rodAll->SetRodVoltShiftA(18,volt0);
+ rodAll->SetRodVoltShiftC(18,volt0);
+ rodAll->SetCopperRodShiftA(18,volt0);
+ rodAll->SetCopperRodShiftC(18,volt0);
+ rodAll->SetRotatedClipVoltA(0,volt0);
+ rodAll->SetRotatedClipVoltC(0,volt0);
+ rodAll->SetRodVoltShiftA(0,volt0);
+ rodAll->SetRodVoltShiftC(0,volt0);
+ rodAll->SetCopperRodShiftA(0,volt0);
+ rodAll->SetCopperRodShiftC(0,volt0);
+ rodAll->SetOmegaTauT1T2(0,1,1);
+ //
+ //
+ // Initialization of the lookup tables
+ //
+ printf(" ------- OFC rotated clip:\n"); rotOFC->InitFCVoltError3D();
+ printf(" ------- OFC rod & strip:\n"); rodOFC1->InitFCVoltError3D();
+ printf(" ------- OFC copper rod:\n"); rodOFC2->InitFCVoltError3D();
+ printf(" ------- IFC rotated clip:\n"); rotIFC->InitFCVoltError3D();
+ printf(" ------- IFC rod & strip:\n"); rodIFC1->InitFCVoltError3D();
+ printf(" ------- IFC copper rod:\n"); rodIFC2->InitFCVoltError3D();
+ printf(" ------- Dummy all:\n"); rodAll->InitFCVoltError3D();
+ // give names
+ rotOFC->SetName("rotOFC");rotOFC->SetTitle("rotOFC");
+ rodOFC1->SetName("rodOFC1");rodOFC1->SetTitle("rodOFC1");
+ rodOFC2->SetName("rodOFC2");rodOFC2->SetTitle("rodOFC2");
+ rotIFC->SetName("rotIFC");rotIFC->SetTitle("rotIFC");
+ rodIFC1->SetName("rodIFC1");rodIFC1->SetTitle("rodIFC1");
+ rodIFC2->SetName("rodIFC2");rodIFC2->SetTitle("rodIFC2");
+ rodAll->SetName("rodAll");rodAll->SetTitle("rodAll");
+ //
+ // save in file
+ AliTPCComposedCorrection *corFit0 = new AliTPCComposedCorrection();
+ TObjArray *cs = new TObjArray();
+ cs->Add(rotIFC); cs->Add(rotOFC);
+ cs->Add(rodIFC1); cs->Add(rodOFC1);
+ cs->Add(rodIFC2); cs->Add(rodOFC2);
+ cs->Add(rodAll);
+ corFit0->SetCorrections(cs);
+ corFit0->SetOmegaTauT1T2(0,1.,1.);
+ corFit0->Print();
+ corFit0->StoreInOCDB(0,1000000,"testForFit");
+ }
+ //
+ AliTPCCorrection::AddVisualCorrection(rotOFC,0);
+ AliTPCCorrection::AddVisualCorrection(rodOFC1,1);
+ AliTPCCorrection::AddVisualCorrection(rodOFC2,2);
+ AliTPCCorrection::AddVisualCorrection(rotIFC,3);
+ AliTPCCorrection::AddVisualCorrection(rodIFC1,4);
+ AliTPCCorrection::AddVisualCorrection(rodIFC2,5);
+ AliTPCCorrection::AddVisualCorrection(rodAll,6);
+}
+
+
+void RegisterAlignFunction(){
+ //
+ // Register primitive alignment components.
+ // Linear conbination of primitev forulas used for fit
+ // The nominal delta 1 mm in shift and 1 mrad in rotation
+ // Primitive formulas registeren in AliTPCCoreection::AddvisualCorrection
+ // 10 - deltaX
+ // 11 - deltaY
+ // 12 - deltaZ
+ // 13 - rot0 (phi)
+ // 14 - rot1 (theta)
+ // 15 - rot2
+ //
+ TGeoHMatrix matrixX;
+ TGeoHMatrix matrixY;
+ TGeoHMatrix matrixZ;
+ TGeoRotation rot0;
+ TGeoRotation rot1;
+ TGeoRotation rot2; //transformation matrices
+ TGeoRotation rot90; //transformation matrices
+ matrixX.SetDx(0.1); matrixY.SetDy(0.1); matrixZ.SetDz(0.1); //1 mm translation
+ rot0.SetAngles(0.001*TMath::RadToDeg(),0,0);
+ rot1.SetAngles(0,0.001*TMath::RadToDeg(),0);
+ rot2.SetAngles(0,0,0.001*TMath::RadToDeg());
+ //how to get rot02 ?
+ rot90.SetAngles(0,90,0);
+ rot2.MultiplyBy(&rot90,kTRUE);
+ rot90.SetAngles(0,-90,0);
+ rot2.MultiplyBy(&rot90,kFALSE);
+ AliTPCCalibGlobalMisalignment *alignRot0 =new AliTPCCalibGlobalMisalignment;
+ alignRot0->SetAlignGlobal(&rot0);
+ AliTPCCalibGlobalMisalignment *alignRot1=new AliTPCCalibGlobalMisalignment;
+ alignRot1->SetAlignGlobal(&rot1);
+ AliTPCCalibGlobalMisalignment *alignRot2=new AliTPCCalibGlobalMisalignment;
+ alignRot2->SetAlignGlobal(&rot2);
+ //
+ AliTPCCalibGlobalMisalignment *alignTrans0 =new AliTPCCalibGlobalMisalignment;
+ alignTrans0->SetAlignGlobal(&matrixX);
+ AliTPCCalibGlobalMisalignment *alignTrans1=new AliTPCCalibGlobalMisalignment;
+ alignTrans1->SetAlignGlobal(&matrixY);
+ AliTPCCalibGlobalMisalignment *alignTrans2=new AliTPCCalibGlobalMisalignment;
+ alignTrans2->SetAlignGlobal(&matrixZ);
+ AliTPCCorrection::AddVisualCorrection(alignTrans0 ,10);
+ AliTPCCorrection::AddVisualCorrection(alignTrans1 ,11);
+ AliTPCCorrection::AddVisualCorrection(alignTrans2 ,12);
+ AliTPCCorrection::AddVisualCorrection(alignRot0 ,13);
+ AliTPCCorrection::AddVisualCorrection(alignRot1 ,14);
+ AliTPCCorrection::AddVisualCorrection(alignRot2 ,15);
+ TObjArray arrAlign(6);
+ arrAlign.AddAt(alignTrans0->Clone(),0);
+ arrAlign.AddAt(alignTrans1->Clone(),1);
+ arrAlign.AddAt(alignTrans2->Clone(),2);
+ arrAlign.AddAt(alignRot0->Clone(),3);
+ arrAlign.AddAt(alignRot1->Clone(),4);
+ arrAlign.AddAt(alignRot2->Clone(),5);
+ //combAlign.SetCorrections((TObjArray*)arrAlign.Clone());
+}
+
+
+void LoadTrees(){
+ //
+ // 1. Load trees
+ // 2. Make standard cuts - filter the tree
+ // 3. makeStandard aliases
+ //
+ TFile *fy = new TFile("clusterDY.root");
+ TFile *fz = new TFile("clusterDZ.root");
+ treeDY= (TTree*)fy->Get("delta");
+ treeDZ= (TTree*)fz->Get("delta");
+ TCut cutAll = "entries>3000&&abs(kZ)<1&&localX>80&&localX<246&&abs(sector-int(sector)-0.5)<0.41&&abs(localX-134)>2&&rmsG<0.5&&abs(localX-189)>3";
+
+ treeDY->Draw(">>outListY",cutAll,"entryList");
+ TEntryList *elistOutY = (TEntryList*)gDirectory->Get("outListY");
+ treeDY->SetEntryList(elistOutY);
+ treeDZ->Draw(">>outListZ",cutAll,"entryList");
+ TEntryList *elistOutZ = (TEntryList*)gDirectory->Get("outListZ");
+ treeDZ->SetEntryList(elistOutZ);
+ //
+ // Make aliases
+ //
+ treeDY->SetAlias("dsec","(sector-int(sector)-0.5)");
+ treeDY->SetAlias("dsec0","(sector-int(sector))");
+ treeDY->SetAlias("signy","(-1.+2*(sector-int(sector)>0.5))");
+ treeDY->SetAlias("dx","(localX-165.5)"); // distance X to ref. plane
+ treeDY->SetAlias("dxm","0.001*(localX-165.5)");
+ treeDY->SetAlias("rx","(localX/166.5)"); //ratio distrnace to reference plane
+ treeDY->SetAlias("dq1","(((q1==0)*(-rx)+q1*(1-rx))*signy)");
+ //
+ {for (Int_t isec=0; isec<18; isec++){ // sectors
+ treeDY->SetAlias(Form("sec%d",isec), Form("(abs(sector-%3.1lf)<0.5)",isec+0.5));
+ treeDZ->SetAlias(Form("sec%d",isec), Form("(abs(sector-%3.1lf)<0.5)",isec+0.5));
+ }}
+ treeDY->SetAlias("gy","localX*sin(pi*sector/9)");
+ treeDY->SetAlias("gx","localX*cos(pi*sector/9)");
+ treeDY->SetAlias("side","(-1.+2.*(kZ>0))");
+ treeDY->SetAlias("drphi","mean");
+ treeDY->SetMarkerStyle(25);
+}
+
+Double_t DeltaLookup(Double_t sector, Double_t localX, Double_t kZ, Double_t xref, Int_t value, Int_t corr){
+ //
+ // Distortion maps are calculated relative to the reference X plane
+ // The same procedure applied for given correction
+ // fd(sector, localX, kZ) ==> fd(sector, localX, kZ)-fd(sector, xref, kZ)*localX/xref
+ //
+ Double_t distortion = AliTPCCorrection::GetCorrSector(sector,localX,kZ,value,corr);
+ Double_t distortionRef = AliTPCCorrection::GetCorrSector(sector,xref,kZ,value,corr)*localX/xref;
+ return distortion-distortionRef;
+}
+
+void MakeAliases(){
+ //
+ // make alias names
+ //
+ AliTPCROC * roc = AliTPCROC::Instance();
+ Double_t xref = ( roc->GetPadRowRadii(0,0)+roc->GetPadRowRadii(36,roc->GetNRows(36)-1))*0.5;
+ treeDY->SetAlias("iroc","(localX<134)"); // IROC
+ treeDY->SetAlias("oroc","(localX>134)"); // OROC
+ treeDY->SetAlias("q1","abs(localX-161)<28"); // OROC first haf
+ treeDY->SetAlias("q2","(localX>189)"); // OROC second half
+ //
+ treeDY->SetAlias("dIFC","abs(localX-83)"); // distance to IFC
+ treeDY->SetAlias("dOFC","abs(localX-250)"); // distance to OFC
+ treeDY->SetAlias("errY","(1.+1/(1+(dIFC/2.))+1/(1+dOFC/2.))");
+
+ //
+ // rotated clip - IFC --------------------
+ treeDY->SetAlias("rotClipI","DeltaLookup(sector,localX,kZ,165.6,1,3+0)");
+ // rotated clip - OFC --------------------
+ treeDY->SetAlias("rotClipO","DeltaLookup(sector,localX,kZ,165.6,1,0+0)");
+ for (Int_t isec=0;isec<18; isec++){
+ //
+ // alignment IROC - shift cm - rotation mrad
+ treeDY->SetAlias(Form("dyI_%d",isec),Form("(iroc*sec%d)",isec));
+ treeDY->SetAlias(Form("drotI_%d",isec),Form("(iroc*sec%d*(localX-%3.1lf)/1000.)",isec,xref));
+ // alignment OROC
+ treeDY->SetAlias(Form("dyO_%d",isec),Form("(sec%d*oroc-sec%d*localX/165.6)",isec,isec)); // fix local Y shift - do not use it
+ treeDY->SetAlias(Form("drotO_%d",isec),Form("(sec%d*oroc*(localX-%3.1lf)/1000.)",isec,xref));
+ //
+ // quadrant shift OROC
+ treeDY->SetAlias(Form("dqO0_%d",isec),Form("(sec%d*sign(dsec)*(q1-localX/165.6))",isec));
+ // quadrant delta rotation OFC inner
+ treeDY->SetAlias(Form("dqOR0_%d",isec),Form("(sec%d*sign(dsec)*q1*(localX-165.6)/1000.)",isec));
+ //
+ treeDY->SetAlias(Form("dqO1_%d",isec),Form("(q2*sec%d*sign(dsec))",isec)); // delta
+ treeDY->SetAlias(Form("dqOR1_%d",isec),Form("(q2*sec%d*sign(dsec)*(localX-165.6)/1000.)",isec));
+ treeDY->SetAlias(Form("dqO2_%d",isec),Form("(q2*sec%d)",isec)); //common
+ treeDY->SetAlias(Form("dqOR2_%d",isec),Form("(q2*sec%d*(localX-165.6)/1000.)",isec));
+ //
+ //
+ // shifted rod - OFC
+ treeDY->SetAlias(Form("rodStripO_%d",isec),Form("DeltaLookup(sector-%d,localX,kZ,165.6,1,1+0)",isec));
+ // Shifted cooper rod OFC
+ treeDY->SetAlias(Form("coppRodO_%d",isec),Form("DeltaLookup(sector-%d,localX,kZ,165.6,1,2+0)",isec));
+ // shifted rod - IFC
+ treeDY->SetAlias(Form("rodStripI_%d",isec),Form("DeltaLookup(sector-%d,localX,kZ,165.6,1,4+0)",isec));
+ // Shifted cooper rod IFC
+ treeDY->SetAlias(Form("coppRodI_%d",isec),Form("DeltaLookup(sector-%d,localX,kZ,165.6,1,5+0)",isec));
+ }
+ //
+ // fitted correction - Using the saved coposed corrections
+ //
+ treeDY->SetAlias("dAlign","DeltaLookup(sector,localX,kZ,165.6,1,1000+0)");
+ treeDY->SetAlias("dQuadrant","DeltaLookup(sector,localX,kZ,165.6,1,1100+0)");
+ treeDY->SetAlias("dField","DeltaLookup(sector,localX,kZ,165.6,1,100+0)");
+ treeDY->SetAlias("dAll","(dAlign+dQuadrant+dField)");
+}
+
+AliTPCCalibGlobalMisalignment *MakeAlignCorrection(TVectorD paramA, TVectorD paramC, TMatrixD covar, Double_t chi2){
+ //
+ // Make a global alignmnet
+ // Take a fit parameters and make a combined correction:
+ // Only delta local Y and delta phi are fitted - not sensitivity for other parameters
+ // GX and GY shift extracted per side.
+ //
+ // Algorithm:
+ // 1. Loop over sectors
+ // 2. Make combined AliTPCCalibGlobalMisalignment
+ //
+ AliTPCCalibGlobalMisalignment *alignLocal =new AliTPCCalibGlobalMisalignment;
+ Int_t offset=3;
+ AliTPCROC * roc = AliTPCROC::Instance();
+ Double_t xref = ( roc->GetPadRowRadii(0,0)+roc->GetPadRowRadii(36,roc->GetNRows(36)-1))*0.5;
+ //
+ pcWorkspace->GetFile()->cd();
+ TObjArray * array = new TObjArray(72);
+
+ for (Int_t side=-1; side<2; side+=2){
+ TVectorD ¶m = (side==1) ? paramA : paramC;
+ TGeoHMatrix matrixGX;
+ TGeoHMatrix matrixGY;
+ matrixGX.SetDx(0.1*param[1]);
+ matrixGY.SetDy(0.1*param[2]);
+ //
+ for (Int_t isec=0; isec<18; isec++){
+ TGeoHMatrix matrixOROC;
+ TGeoHMatrix matrixIROC;
+ TGeoRotation rotIROC;
+ TGeoRotation rotOROC;
+ Double_t phi= (Double_t(isec)+0.5)*TMath::Pi()/9.;
+ //
+ Double_t drotIROC = -param[offset+isec+18]*0.001;
+ Double_t drotOROC = -param[offset+isec+36]*0.001;
+ Double_t dlyIROC = param[offset+isec];
+ Double_t dlyIROC0 = param[offset+isec]+drotIROC*xref; // shift at x=0
+ Double_t dlyOROC = 0;
+ Double_t dlyOROC0 = 0+drotOROC*xref; // shift at x=0
+ //
+ Double_t dgxIROC = TMath::Cos(phi)*0+TMath::Sin(phi)*dlyIROC0;
+ Double_t dgyIROC = TMath::Sin(phi)*0-TMath::Cos(phi)*dlyIROC0;
+ Double_t dgxOROC = TMath::Cos(phi)*0+TMath::Sin(phi)*dlyOROC0;
+ Double_t dgyOROC = TMath::Sin(phi)*0-TMath::Cos(phi)*dlyOROC0;
+ Double_t errYIROC=TMath::Sqrt(covar(offset+isec, offset+isec)*chi2);
+ Double_t errPhiIROC=TMath::Sqrt(covar(offset+isec+18, offset+isec+18)*chi2);
+ Double_t errPhiOROC=TMath::Sqrt(covar(offset+isec+36, offset+isec+36)*chi2);
+ matrixIROC.SetDx(dgxIROC);
+ matrixIROC.SetDy(dgyIROC);
+ matrixOROC.SetDx(dgxOROC);
+ matrixOROC.SetDy(dgyOROC);
+ rotIROC.SetAngles(drotIROC*TMath::RadToDeg(),0,0);
+ matrixIROC.Multiply(&matrixGX);
+ matrixIROC.Multiply(&matrixGY);
+ matrixIROC.Multiply(&rotIROC);
+ rotOROC.SetAngles(drotOROC*TMath::RadToDeg(),0,0);
+ matrixOROC.Multiply(&matrixGX);
+ matrixOROC.Multiply(&matrixGY);
+ matrixOROC.Multiply(&rotOROC);
+ if (side>0){
+ array->AddAt(matrixIROC.Clone(),isec);
+ array->AddAt(matrixOROC.Clone(),isec+36);
+ }
+ if (side<0){
+ array->AddAt(matrixIROC.Clone(),isec+18);
+ array->AddAt(matrixOROC.Clone(),isec+36+18);
+ }
+ Double_t rms=TMath::Sqrt(chi2); //chi2 normalized 1/npoints before
+ (*pcWorkspace)<<"align"<<
+ "isec="<<isec<< // sector
+ "side="<<side<< // side
+ "phi="<<phi<< // phi
+ "rms="<<rms<< // rms in cm
+ "cov.="<<&covar<<
+ // errors
+ "errYIROC="<<errYIROC<< //error in local y
+ "errPhiIROC="<<errPhiIROC<< //error in phi IROC
+ "errPhiOROC="<<errPhiOROC<< //error in phi OROC
+ //
+ "dlyIROC="<<dlyIROC<< //delta Local Y at refX=165 -IROC
+ "dlyIROC0="<<dlyIROC0<< //delta Local Y at refX=0 -IROC
+ "dgxIROC="<<dgxIROC<< //
+ "dgyIROC="<<dgyIROC<<
+ "drotIROC="<<drotIROC<<
+ //
+ "dlyOROC="<<dlyOROC<< // assuming 0 at
+ "dlyOROC0="<<dlyOROC0<<
+ "dgxOROC="<<dgxOROC<<
+ "dgyOROC="<<dgyOROC<<
+ "drotOROC="<<drotOROC<<
+ "\n";
+ }
+ }
+ alignLocal->SetAlignSectors(array);
+ AliTPCCorrection::AddVisualCorrection(alignLocal,1000);
+ /*
+ Check:
+ alignLocal->CreateHistoDRPhiinXY(10,100,100)->Draw("colz"); // OK
+ treeDY->Draw("DeltaLookup(sector,localX,kZ,165.6,1,1001):localX:int(sector)","kZ>0","colz");
+ //
+ (( (*pcWorkspace)<<"align"))->GetTree()->Draw("dlyOROC-dlyOROC:isec","","*")
+ treeDY->Draw("tfitA:DeltaLookup(sector,localX,kZ,165.6,1,1001):sector","kZ>0","colz");
+
+ */
+ return alignLocal;
+}
+
+AliTPCCalibGlobalMisalignment *MakeQuadrantCorrection(TVectorD paramA, TVectorD paramC, TMatrixD covar, Double_t chi2){
+ //
+ // Make a global alignmnet
+ // side= 1 - A side
+ // side=-1 - C side
+ // Take a fit parameters and make a combined correction:
+ // Only delta local Y and delta phi are fitted - not sensitivity for other parameters
+ // GX and GY shift extracted per side.
+ //
+ // Algorithm:
+ // 1. Loop over sectors
+ // 2. Make combined AliTPCCalibGlobalMisalignment
+ //
+ AliTPCCalibGlobalMisalignment *alignLocalQuadrant =new AliTPCCalibGlobalMisalignment;
+ //
+ Int_t offset=3+3*18;
+ TVectorD quadrantQ0(36); //dly+=sign*(*fQuadrantQ0)[isec]; // shift in cm
+ TVectorD quadrantRQ0(36); //dly+=sign*(*fQuadrantRQ0)[isec]*(pos[0]-xref);
+ TVectorD quadrantQ1(36); //dly+=sign*(*fQuadrantQ1)[isec]; // shift in cm
+ TVectorD quadrantRQ1(36); //dly+=sign*(*fQuadrantRQ1)[isec]*(pos[0]-xref);
+ TVectorD quadrantQ2(36); //dly+=(*fQuadrantQ2)[isec]; // shift in cm
+ TVectorD quadrantRQ2(36); //dly+=(*fQuadrantRQ2)[isec]*(pos[0]-xref);
+
+ for (Int_t side=-1; side<2; side+=2){
+ Int_t offsetSec= (side==1) ? 0:18;
+ TVectorD ¶m = (side==1) ? paramA : paramC;
+ for (Int_t isec=0; isec<18; isec++){
+ Double_t q0=-param[offset+isec+0*18];
+ Double_t rq0=-param[offset+isec+1*18]*0.001;
+ Double_t q1=-param[offset+isec+2*18];
+ Double_t rq1=-param[offset+isec+3*18]*0.001;
+ Double_t q2=-param[offset+isec+4*18];
+ Double_t rq2=-param[offset+isec+5*18]*0.001;
+ //
+ Double_t sq0=TMath::Sqrt(covar(offset+isec+0*18,offset+isec+0*18)*chi2);
+ Double_t srq0=TMath::Sqrt(covar(offset+isec+1*18,offset+isec+1*18)*chi2)*0.001;
+ Double_t sq1=TMath::Sqrt(covar(offset+isec+2*18,offset+isec+2*18)*chi2);
+ Double_t srq1=TMath::Sqrt(covar(offset+isec+3*18,offset+isec+3*18)*chi2)*0.001;
+ Double_t sq2=TMath::Sqrt(covar(offset+isec+4*18,offset+isec+4*18)*chi2);
+ Double_t srq2=TMath::Sqrt(covar(offset+isec+5*18,offset+isec+5*18)*chi2)*0.001;
+ //
+ quadrantQ0[offsetSec+isec]=q0;
+ quadrantRQ0[offsetSec+isec]=rq0;
+ quadrantQ1[offsetSec+isec]=q1;
+ quadrantRQ1[offsetSec+isec]=rq1;
+ quadrantQ2[offsetSec+isec]=q2;
+ quadrantRQ2[offsetSec+isec]=rq2;
+ Double_t rms=TMath::Sqrt(chi2); //chi2 normalized 1/npoints before
+ (*pcWorkspace)<<"quadrant"<<
+ "isec="<<isec<< // sector
+ "side="<<side<< // side
+ "rms="<<rms<< // rms in cm
+ "cov.="<<&covar<<
+ //
+ "q0="<<q0<< // quadrant alignment
+ "rq0="<<rq0<<
+ "q1="<<q1<<
+ "rq1="<<rq1<<
+ "q2="<<q2<<
+ "rq2="<<rq2<<
+ "sq0="<<sq0<< //rms of quadrant parameters
+ "srq0="<<srq0<<
+ "sq1="<<sq1<<
+ "srq1="<<srq1<<
+ "sq2="<<sq2<<
+ "srq2="<<srq2<<
+ "\n";
+ }
+ }
+ alignLocalQuadrant->SetQuadranAlign(&quadrantQ0, &quadrantRQ0, &quadrantQ1, &quadrantRQ1, &quadrantQ2, &quadrantRQ2);
+ AliTPCCorrection::AddVisualCorrection(alignLocalQuadrant,1100);
+ /*
+ (( (*pcWorkspace)<<"quadrant"))->GetTree()->Draw("q0:isec","","*")
+
+ alignLocalQuadrant->CreateHistoDRPhiinXY(10,100,100)->Draw("colz"); //OK
+
+ treeDY->Draw("tfitA-DeltaLookup(sector,localX,kZ,165.6,1,1000):DeltaLookup(sector,localX,kZ,165.6,1,1100):int(sector)","kZ>0&&oroc","colz");
+ */
+ return alignLocalQuadrant;
+}
+
+AliTPCFCVoltError3D* MakeEfieldCorrection(TVectorD paramA, TVectorD paramC, TMatrixD covar, Double_t chi2){
+ //
+ // Make a global AliTPCFCVoltError3D object
+ //
+ // Take a fit parameters and make a combined correction:
+ // Only delta local Y and delta phi are fitted - not sensitivity for other parameters
+ // GX and GY shift extracted per side.
+ //
+ // Algorithm:
+ // 1. Loop over sectors
+ // 2. Make combined AliTPCCalibGlobalMisalignment
+ //
+ Int_t offset=3+9*18;
+ //
+ AliTPCFCVoltError3D* corrField = new AliTPCFCVoltError3D;
+ //
+ Double_t rotIROCA=paramA[offset+0];
+ Double_t rotIROCC=paramC[offset+0];
+ Double_t rotOROCA=paramA[offset+1];
+ Double_t rotOROCC=paramC[offset+1];
+ //
+ corrField->SetRotatedClipVoltA(0,paramA[offset+0]);
+ corrField->SetRotatedClipVoltC(0,paramC[offset+0]);
+ corrField->SetRotatedClipVoltA(1,paramA[offset+1]);
+ corrField->SetRotatedClipVoltC(1,paramC[offset+1]);
+ {for (Int_t isec=0; isec<18; isec++){
+ corrField->SetRodVoltShiftA(isec,paramA[offset+2+36+isec]); // rod shift IFC
+ corrField->SetRodVoltShiftA(18+isec,paramA[offset+2+isec]); // rod shift OFC
+ corrField->SetRodVoltShiftC(isec,paramC[offset+2+36+isec]); // rod shift IFC
+ corrField->SetRodVoltShiftC(18+isec,paramC[offset+2+isec]); // rod shift OFC
+ Double_t rodIROCA=paramA[offset+2+36+isec];
+ Double_t rodIROCC=paramC[offset+2+36+isec];
+ Double_t rodOROCA=paramA[offset+2+isec];
+ Double_t rodOROCC=paramC[offset+2+isec];
+ //
+ Double_t srodIROCA=TMath::Sqrt(covar(offset+2+36+isec,offset+2+36+isec)*chi2);
+ Double_t srodOROCA=TMath::Sqrt(covar(offset+2+isec,offset+2+isec)*chi2);
+ Double_t phi= (Double_t(isec)+0.5)*TMath::Pi()/9.;
+ Double_t rms=TMath::Sqrt(chi2); //chi2 normalized 1/npoints before
+ (*pcWorkspace)<<"field"<<
+ "isec="<<isec<< // sector
+ //"side="<<side<< // side
+ "phi="<<phi<< // phi
+ "rms="<<rms<< // rms in cm
+ "cov.="<<&covar<<
+ //
+ "rotIROCA="<<rotIROCA<<
+ "rotIROCC="<<rotIROCC<<
+ "rotOROCA="<<rotOROCA<<
+ "rotOROCC="<<rotOROCC<<
+ //
+ "rodIROCA="<<rodIROCA<<
+ "rodIROCC="<<rodIROCC<<
+ "rodOROCA="<<rodOROCA<<
+ "rodOROCC="<<rodOROCC<<
+ //
+ "srodIROCA="<<srodIROCA<<
+ "srodOROCA="<<srodOROCA<<
+ "srodIROCC="<<srodIROCA<<
+ "srodOROCC="<<srodOROCA<<
+ "\n";
+ }
+ }
+ corrField->SetOmegaTauT1T2(0,1.,1.);
+ corrField->InitFCVoltError3D();
+ AliTPCCorrection::AddVisualCorrection(corrField,100);
+ return corrField;
+}
+
+
+void FitRodShift(Bool_t flagIFCcopper = kTRUE) {
+ //
+ // Main fit function
+ // In total 440 parameters to fit using global fit:
+ // 1. Rotation and translation for each sector (72x2)
+ // 2. Rotation and translation for each quadrant of OROC (36x4x2)
+ // 3. Rod/strip shifts in IFC and OFC (18 sectors x 2 sides x 2 )
+ // 4. Rotated clips in IFC and OFC
+ //
+ LoadTrees();
+ LoadModels();
+ RegisterAlignFunction();
+ MakeAliases();
+
+ pcWorkspace= new TTreeSRedirector("fitAlignLookup.root");
+ TFormula::SetMaxima(10000);
+ //
+ // 1. fit Global
+ //
+ Double_t chi2G=0; Int_t npointsG=0; TVectorD paramG; TMatrixD covarG;
+ TString fstringGlobal="";
+ fstringGlobal+="DeltaLookup(sector,localX,kZ,165.6,1,10-0)++"; // deltaGX
+ fstringGlobal+="DeltaLookup(sector,localX,kZ,165.6,1,11-0)++"; // deltaGY
+ fstringGlobal+="DeltaLookup(sector,localX,kZ,165.6,1,10-0)*side++"; // deltaGX - sides
+ fstringGlobal+="DeltaLookup(sector,localX,kZ,165.6,1,11-0)*side++"; // deltaGY -sides
+ //
+ TString *strFitGlobal = TStatToolkit::FitPlane(treeDY,"drphi", fstringGlobal.Data(),"1", chi2G,npointsG,paramG,covarG,-1,0, 10000000, kTRUE);
+ treeDY->SetAlias("fitYGlobal",strFitGlobal->Data());
+ strFitGlobal->Tokenize("++")->Print();
+ printf("chi2=%f\n",TMath::Sqrt(chi2G/npointsG));
+ // testplots - if necessary - e.g.
+ // treeDY->Draw("AliTPCCorrection::GetCorrSector(sector,localX,kZ,1,2):sector:localX","Cut","colz")
+
+ // FIT PREPARATION +++++++++++++++++++++++++++++++++
+ // define the fit function
+
+ TString fstring="";
+
+ //
+ // Alignment
+ //
+ {
+ fstring+="DeltaLookup(sector,localX,kZ,165.6,1,10-0)++"; // deltaGX
+ fstring+="DeltaLookup(sector,localX,kZ,165.6,1,11-0)++"; // deltaGY
+ // alignment IROC
+ for (Int_t i=0;i<18;i++){
+ fstring+=Form("dyI_%d++",i); // alignment - linear shift (in cm)
+ }
+ for (Int_t i=0;i<18;i++){
+ fstring+=Form("drotI_%d++",i); // alignment - rotation (in mrad)
+ }
+ // alignment OROC
+ for (Int_t i=0;i<18;i++){ // shift of OROC is not allowed
+ //fstring+=Form("dyO_%d++",i); // alignment - linear shift (in cm)
+ }
+ for (Int_t i=0;i<18;i++){
+ fstring+=Form("drotO_%d++",i); // alignment - rotation (in mrad)
+ }
+ //
+ for (Int_t i=0;i<18;i++){
+ fstring+=Form("dqO0_%d++",i); // alignment - quadrant shift OROC in
+ }
+ for (Int_t i=0;i<18;i++){
+ fstring+=Form("dqOR0_%d++",i); // alignment - quadrant rotation OROC in
+ }
+ for (Int_t i=0;i<18;i++){
+ fstring+=Form("dqO1_%d++",i); // alignment - quadrant shift OROC out
+ }
+ for (Int_t i=0;i<18;i++){
+ fstring+=Form("dqOR1_%d++",i); // alignment - quadrant rotation OROC out
+ }
+ for (Int_t i=0;i<18;i++){
+ fstring+=Form("dqO2_%d++",i); // alignment - quadrant shift OROC out
+ }
+ for (Int_t i=0;i<18;i++){
+ fstring+=Form("dqOR2_%d++",i); // alignment - quadrant rotation OROC out
+ }
+ }
+ //
+ // Field distortion
+ //
+ {
+ // rotated clip - IFC --------------------
+ treeDY->SetAlias("rotClipI","DeltaLookup(sector,localX,kZ,165.6,1,3+0)");
+ fstring+="rotClipI++";
+ // rotated clip - OFC --------------------
+ treeDY->SetAlias("rotClipO","DeltaLookup(sector,localX,kZ,165.6,1,0+0)");
+ fstring+="rotClipO++";
+
+ // shifted rod - OFC
+ for (Int_t i=0;i<18;i++){
+ fstring+=Form("rodStripO_%d++",i);
+ }
+ // Shifted cooper rod OFC
+ for (Int_t i=0;i<18;i++){
+ fstring+=Form("coppRodO_%d++",i);
+ }
+ // shifted rod - IFC
+ for (Int_t i=0;i<18;i++){
+ fstring+=Form("rodStripI_%d++",i);
+ }
+ // Shifted cooper rod IFC
+ if (flagIFCcopper) for (Int_t i=0;i<18;i++){
+ fstring+=Form("coppRodI_%d++",i);
+ }
+ }
+ //fstring+=fstringGlobal;
+
+ // FIT ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+ Double_t chi2A=0; Int_t npointsA=0; TVectorD paramA; TMatrixD covarA;
+ Double_t chi2C=0; Int_t npointsC=0; TVectorD paramC; TMatrixD covarC;
+
+
+ printf("Fitting A side\n");
+ TCut cutAllA = "Cut&&kZ>0";
+ TString *strFitGA = TStatToolkit::FitPlane(treeDY,"drphi:errY", fstring.Data(),"kZ>0", chi2A,npointsA,paramA,covarA,-1,0, 10000000, kTRUE);
+ treeDY->SetAlias("tfitA",strFitGA->Data());
+ // strFitGA->Tokenize("++")->Print();
+ printf("chi2=%f\n",TMath::Sqrt(chi2A/npointsA));
+ printf("Sigma Y:\t%f (mm)\n",10.*TMath::Sqrt(covarA(3,3)*chi2A/npointsA));
+ printf("IROC Sigma Angle:\t%f (mrad)\n",TMath::Sqrt(covarA(3+18,3+18)*chi2A/npointsA));
+ printf("OROC Sigma Angle:\t%f (mrad)\n",TMath::Sqrt(covarA(3+36,3+36)*chi2A/npointsA));
+
+ printf("Fitting C side\n");
+ TCut cutAllC = "Cut&&kZ<0";
+ TString *strFitGC = TStatToolkit::FitPlane(treeDY,"drphi:errY", fstring.Data(),"kZ<0", chi2C,npointsC,paramC,covarC,-1,0, 10000000, kTRUE);
+ treeDY->SetAlias("tfitC",strFitGC->Data());
+ // strFitGC->Tokenize("++")->Print();
+ printf("chi2=%f\n",TMath::Sqrt(chi2C/npointsC));
+ printf("Sigma Y:\t%f (mm)\n",10.*TMath::Sqrt(covarC(3,3)*chi2C/npointsC));
+ printf("IROC Sigma Angle:\t%f (mrad)\n",TMath::Sqrt(covarC(3+18,3+18)*chi2C/npointsC));
+ printf("OROC Sigma Angle:\t%f (mrad)\n",TMath::Sqrt(covarC(3+36,3+36)*chi2C/npointsC));
+
+ //
+ // make combined correction
+ //
+ TH2 *hdist =0;
+ //
+ AliTPCCalibGlobalMisalignment * alignLocal = MakeAlignCorrection(paramA, paramC, covarA, chi2A/npointsA);
+ alignLocal->SetName("alignLocal");
+ alignLocal->Write("alignLocal");
+ hdist = alignLocal->CreateHistoDRPhiinXY(10,250,250);
+ hdist->SetName("AlignLocalAside"); hdist->SetTitle("Alignment map (A side)");
+ hdist->Write("AlignLocalAside");
+ hdist = alignLocal->CreateHistoDRPhiinXY(-10,250,250);
+ hdist->SetName("AlignLocalCside"); hdist->SetTitle("Alignment map (C side)");
+ hdist->Write("AlignLocalCside");
+ //
+ AliTPCCalibGlobalMisalignment *alignQuadrant = MakeQuadrantCorrection(paramA, paramC, covarA, chi2A/npointsA);
+ alignQuadrant->SetName("alignQuadrant");
+ alignQuadrant->Write("alignQuadrant");
+ hdist = alignQuadrant->CreateHistoDRPhiinXY(10,250,250);
+ hdist->SetName("AlignQuadrantAside"); hdist->SetTitle("Quadrant Alignment map (A side)");
+ hdist->Write("AlignQuadrantAside");
+ hdist = alignQuadrant->CreateHistoDRPhiinXY(-10,250,250);
+ hdist->SetName("AlignQuadrantCside"); hdist->SetTitle("Quadrant Alignment map (C side)");
+ hdist->Write("AlignQuadrantCside");
+ //
+ AliTPCFCVoltError3D* corrField = MakeEfieldCorrection(paramA, paramC, covarA, chi2A/npointsA);
+ corrField->SetName("corrField");
+ corrField->Write("corrField");
+
+ hdist = corrField->CreateHistoDRPhiinXY(10,250,250);
+ hdist->SetName("AlignEfieldAside"); hdist->SetTitle("Efield Alignment map (A side)");
+ hdist->Write("AlignEfieldAside");
+ hdist = corrField->CreateHistoDRPhiinXY(-10,250,250);
+ hdist->SetName("AlignEfieldCside"); hdist->SetTitle("Efield Alignment map (C side)");
+ hdist->Write("AlignEfieldCside");
+
+
+ //
+ delete pcWorkspace;
+ MakeQA();
+ return;
+}
+
+
+void MakeQA(){
+ LoadTrees();
+ LoadModels();
+ RegisterAlignFunction();
+ MakeAliases();
+ TFile f("fitAlignLookup.root","update");
+ AliTPCCalibGlobalMisalignment* alignLocal = (AliTPCCalibGlobalMisalignment*)f.Get("alignLocal");
+ AliTPCCalibGlobalMisalignment* alignQuadrant = (AliTPCCalibGlobalMisalignment*)f.Get("alignQuadrant");
+ AliTPCFCVoltError3D *corrField= (AliTPCFCVoltError3D*)f.Get("corrField");
+ AliTPCCorrection::AddVisualCorrection(alignLocal,1000);
+ AliTPCCorrection::AddVisualCorrection(alignQuadrant,1100);
+ AliTPCCorrection::AddVisualCorrection(corrField,100);
+ FitFunctionQA();
+ DrawAlignParam();
+ f.Close();
+}
+
+void FitFunctionQA(){
+ //
+ //
+ //
+ TH1 *his=0;
+ TCanvas *canvasDist= new TCanvas("FitQA","fitQA",1200,800);
+ canvasDist->Divide(2,2);
+ //
+ canvasDist->cd(1)->SetLogy(kFALSE); canvasDist->cd(1)->SetRightMargin(0.15);
+ treeDY->Draw("10*mean:sector:localX","kZ<0&&localX<134","colz");
+ his= (TH1*)treeDY->GetHistogram()->Clone(); his->SetName("DeltaRPhi1");
+ his->GetXaxis()->SetTitle("Sector");
+ his->GetZaxis()->SetTitle("R (cm)");
+ his->GetYaxis()->SetTitle("#Delta_{r#phi} (mm)");
+ his->Draw("cont2");
+ his->Draw("colz");
+ //
+ canvasDist->cd(2)->SetLogy(kFALSE); canvasDist->cd(2)->SetRightMargin(0.15);
+ treeDY->Draw("10*mean:sector:localX","kZ<0&&localX>160","colz");
+ his= (TH1*)treeDY->GetHistogram()->Clone(); his->SetName("DeltaRPhi2");
+ his->GetXaxis()->SetTitle("Sector");
+ his->GetZaxis()->SetTitle("R (cm)");
+ his->GetYaxis()->SetTitle("#Delta_{r#phi} (mm)");
+ his->Draw("cont2");
+ his->Draw("colz");
+ //
+ canvasDist->cd(3)->SetLogy(kFALSE); canvasDist->cd(3)->SetRightMargin(0.15);
+ treeDY->Draw("10*(mean-dAll):sector:localX","kZ<0&&localX<134","colz");
+ his= (TH1*)treeDY->GetHistogram()->Clone(); his->SetName("DeltaRPhi3"); his->SetTitle("Delta #RPhi");
+ his->GetXaxis()->SetTitle("Sector");
+ his->GetZaxis()->SetTitle("R (cm)");
+ his->GetYaxis()->SetTitle("#Delta_{r#phifit}-#Delta_{r#phi} (mm)");
+ his->Draw("cont2");
+ his->Draw("colz");
+ //
+ canvasDist->cd(4)->SetLogy(kFALSE); canvasDist->cd(4)->SetRightMargin(0.15);
+ treeDY->SetMarkerColor(1);
+ treeDY->Draw("10*mean:10*dAll:localX","","colz");
+ his= (TH1*)treeDY->GetHistogram()->Clone(); his->SetName("DeltaRPhi4");
+ his->GetXaxis()->SetTitle("Fit value #Delta_{r#phi} (mm)");
+ his->GetYaxis()->SetTitle("#Delta_{r#phi} (mm)");
+ his->GetZaxis()->SetTitle("R (cm)");
+ his->Draw("cont2");
+ his->Draw("colz");
+ //
+ canvasDist->Write("FitQA");
+}
+
+void DrawAlignParam(){
+ //
+ //
+ //
+ TFile f("fitAlignLookup.root");
+ TTree * treeAlign=(TTree*)f.Get("align");
+ TTree * treeQuadrant=(TTree*)f.Get("quadrant");
+ TCanvas *canvasAlign=new TCanvas("align","align",1000,800);
+ TH1 *his=0;
+ canvasAlign->Divide(2,2);
+ treeAlign->SetMarkerStyle(25);
+ treeQuadrant->SetMarkerStyle(25);
+ gStyle->SetOptStat(kTRUE);
+ //
+ canvasAlign->cd(1); canvasAlign->cd(1)->SetRightMargin(0.15);
+ treeAlign->Draw("10*dlyIROC*side:isec:1+side","","colz");
+ his= (TH1*)treeAlign->GetHistogram()->Clone(); his->SetName("dlyIROC");his->SetTitle("IROC Alignment #Delta_{r#phi}");
+ his->GetXaxis()->SetTitle("sector");
+ his->GetYaxis()->SetTitle("#Delta_{r#phi} (mm)");
+ his->GetZaxis()->SetTitle("side");
+ his->Draw("cont2");
+ his->Draw("colz");
+ //
+ canvasAlign->cd(2); canvasAlign->cd(2)->SetRightMargin(0.15);
+ treeAlign->Draw("1000*drotIROC*side:isec:1+side","","colz");
+ his= (TH1*)treeAlign->GetHistogram()->Clone(); his->SetName("drotIROC");his->SetTitle("IROC Angular Alignment #Delta_{r#phi}");
+ his->GetXaxis()->SetTitle("sector");
+ his->GetYaxis()->SetTitle("#Delta_{r#phi} (mrad)");
+ his->GetZaxis()->SetTitle("side");
+ his->Draw("cont2");
+ his->Draw("colz");
+ //
+ canvasAlign->cd(4);canvasAlign->cd(4)->SetRightMargin(0.15);
+ treeAlign->Draw("1000*drotOROC*side:isec:1+side","","colz");
+ his= (TH1*)treeAlign->GetHistogram()->Clone(); his->SetName("drotOROC");his->SetTitle("OROC Angular Alignment #Delta_{r#phi}");
+ his->GetXaxis()->SetTitle("sector");
+ his->GetYaxis()->SetTitle("#Delta_{r#phi} (mrad)");
+ his->GetZaxis()->SetTitle("side");
+ his->Draw("cont2");
+ his->Draw("colz");
+ //
+ canvasAlign->cd(3);canvasAlign->cd(3)->SetRightMargin(0.15);
+ treeQuadrant->Draw("10*q2*side:isec:1+side","","colz");
+ his= (TH1*)treeQuadrant->GetHistogram()->Clone(); his->SetName("drphiOROC");his->SetTitle("OROC Alignment Outer Quadrant #Delta_{r#phi}");
+ his->GetXaxis()->SetTitle("sector");
+ his->GetYaxis()->SetTitle("#Delta_{r#phi} (mm)");
+ his->GetZaxis()->SetTitle("side");
+ his->Draw("cont2");
+ his->Draw("colz");
+
+
+}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff