//_____________________________________________________
TLegendEntry* GFHistManager::AddHist(TH1* hist, Int_t layer, const char* legendTitle,
const char* legOpt)
{
// add hist to 'layer'th list of histos (expands, if layer does not already exist!)
if(!hist){
this->Warning("AddHist", "adding NULL pointer will be ignored!");
return NULL;
}
if(!this->CheckDepth("AddHist", layer)) return NULL;
GFHistArray* newHist = new GFHistArray;
newHist->Add(hist);
TObjArray* layerHistArrays = static_cast<TObjArray*>(fHistArrays->At(layer));
layerHistArrays->Add(newHist);
if(legendTitle){
TObjArray* legends = this->MakeLegends(layer);
TLegend* legend = new TLegend(fLegendX1, fLegendY1, fLegendX2, fLegendY2);
#if ROOT_VERSION_CODE < ROOT_VERSION(5,6,0)
if (TString(gStyle->GetName()) == "Plain") legend->SetBorderSize(1);
#endif
legends->AddAtAndExpand(legend, layerHistArrays->IndexOf(newHist));
return legend->AddEntry(hist, legendTitle, legOpt ? legOpt : fgLegendEntryOption.Data());
}
return NULL;
}
//_____________________________________________________
TLegendEntry* GFHistManager::AddHistSame(TH1* hist, Int_t layer, Int_t histNum,
const char* legendTitle, const char* legOpt)
{
// adds hist to layer to draw it in the same pad as histNum's histo of that layer
if(!hist){
this->Warning("AddHistSame", "adding NULL pointer will be ignored!");
return NULL;
}
if (histNum > 0 && this->CheckDepth("AddHistSame", layer, kTRUE) //maybe added layer?
&& !this->GetHistsOf(layer, histNum-1)) {
this->Error("AddHistSame", "usage as AddHist only for next free histNum, not %d", histNum);
return NULL;
}
GFHistArray *histsArray = this->GetHistsOf(layer, histNum, kTRUE);// expand!
TLegendEntry* result = NULL;
if(histsArray) {
histsArray->Add(hist);
if(legendTitle && strlen(legendTitle)){
TObjArray* legends = this->MakeLegends(layer);
TLegend* legend = NULL;
if(legends->GetLast() >= histNum
&& legends->At(histNum)){
legend = static_cast<TLegend*>(legends->At(histNum));
} else {
legend = new TLegend(fLegendX1, fLegendY1, fLegendX2, fLegendY2);
#if ROOT_VERSION_CODE < ROOT_VERSION(5,6,0)
if (TString(gStyle->GetName()) == "Plain") legend->SetBorderSize(1);
#endif
legends->AddAtAndExpand(legend, histNum);
}
result = legend->AddEntry(hist,legendTitle, legOpt ? legOpt : fgLegendEntryOption.Data());
}
}
return result;
}
///
/// Copied from TColor::GetColorDark(Int_t n), but customized
/// the 'darkness'.
///
int ColorBuilder::darklightcolor(int n, float scale)
{
if (n < 0) return -1;
// Get list of all defined colors
TObjArray *colors = (TObjArray*) gROOT->GetListOfColors();
Int_t ncolors = colors->GetSize();
// Get existing color at index n
TColor *color = 0;
if (n < ncolors) color = (TColor*)colors->At(n);
if (!color) return -1;
// Get the rgb of the the new dark color corresponding to color n
Float_t r,g,b;
TColor::HLStoRGB(color->GetHue(), scale*color->GetLight(), color->GetSaturation(), r, g, b);
// Build the dark color (unless the slot nd is already used)
Int_t nd = scale<1. ? n+100 : n+150;
TColor *colord = 0;
if (nd < ncolors) colord = (TColor*)colors->At(nd);
if (colord) return nd;
colord = new TColor(nd,r,g,b);
colord->SetName(scale<1. ? Form("%s_dark",color->GetName()) : Form("%s_light",color->GetName()));
colors->AddAtAndExpand(colord,nd);
return nd;
}
void MakeQAThresholdsEntry(const char* storageUri="local://$ALICE_ROOT/../AliRoot/OCDB", Int_t firstRun=0, Int_t lastRun=999999999)
{
AliCDBManager *cdb = AliCDBManager::Instance();
cdb->SetDefaultStorage(storageUri);
// QAThresholds
TObjArray* qaThrArray = new TObjArray();
for (Int_t idet = 0; idet < AliDAQ::kNDetectors; idet++){
TString detName = AliDAQ::OnlineName(idet);
if (detName == "TRI" || detName == "HLT" || detName == "TST") continue; // skipping TRI, HLT, TST since they do not produce QAThresholds
Printf("Processing QAThreshold for detector %s",detName.Data());
TString inFile(gSystem->ExpandPathName("$ALICE_ROOT/../AliRoot/GRP/ShuttleInput/"));
inFile += "run000168322_";
inFile += detName;
inFile += "_DQM_QAThresholds";
Printf("Opening QAThreshold file %s", inFile.Data());
TFile dqmFile(inFile.Data(),"READ");
if (dqmFile.IsOpen()) {
AliQAThresholds* qaThr = dynamic_cast<AliQAThresholds*>(dqmFile.Get(detName.Data()));
if (qaThr){
Int_t qaThrId = qaThr->GetDetectorId();
if (qaThrId != idet){
Printf("ERROR: Expecting QA threshold for detector %s, but found that for detector %s, skipping",detName.Data(), AliDAQ::OnlineName(qaThrId));
continue;
}
else{
qaThrArray->AddAtAndExpand(qaThr, qaThrId);
}
}
else {
Printf("ERROR: No QAThresholds object found in the file for detector %s, skipping",detName.Data());
continue;
}
}
else {
Printf("ERROR: Can't open QAThreshold file for detector %s, skipping",detName.Data());
continue;
}
}
if (qaThrArray->GetEntries() > 0){
AliCDBMetaData md;
md.SetResponsible("Barthélémy von Haller");
md.SetComment("QA Threshold TObjArray");
AliCDBId id("GRP/Calib/QAThresholds", firstRun, lastRun);
cdb->Put(qaThrArray, id, &md);
}
else{
Printf("No valid QAThresholds entries found, storing nothing in the OCDB");
}
}
//________________________________________________________
TList* GFHistManager::MakeObjList(Int_t layer, Int_t histoNum)
{
// return list of objects to be drawn upon hists in pad histoNum of 'layer'
// (to be called if 'layer' really exist!)
if(!fObjLists) fObjLists = new TObjArray(fDepth);
if(layer > fObjLists->GetLast() || !fObjLists->At(layer)){
fObjLists->AddAtAndExpand(new TObjArray(this->GetNumHistsOf(layer)),layer);
}
TObjArray* layerLists = static_cast<TObjArray*>(fObjLists->At(layer));
if(histoNum > layerLists->GetLast() || !layerLists->At(histoNum)){
layerLists->AddAtAndExpand(new TList, histoNum);
}
return static_cast<TList*>(layerLists->At(histoNum));
}
const char *Next(int &kind,int &idx,double &exe,double &heap,double &free,double &inc) {
if(!inp) return 0;
kind=0;idx=0;exe=0;heap=0;free=0,inc=0;
TString ts;
char *endMaker,*clear,*ctr,*doPs,*fr,*to,*and;
while(fgets(line,500,inp)) {
doPs = strstr(line,"doPs for");
if (!doPs) continue;
endMaker = strstr(line,"EndMaker");
clear = strstr(line,"Clear");
ctr = strstr(line,"constructor");
kind = 0;
if (ctr ) kind = 1;
if (clear ) kind = 2;
if (endMaker) kind = 3;
if (!kind) continue;
fr = doPs+8 +strspn(doPs+8," \t");
to = strstr(fr,":");
ts = ""; ts.Append(fr,to-fr);
if (!ts.Length()) continue;
fr = strstr(fr,"total"); if (!fr) continue;
fr = strstr(fr,"=" ); if (!fr) continue;
exe = atof(fr+1);
fr = strstr(fr,"heap" ); if (!fr) continue;
fr = strstr(fr,"=" ); if (!fr) continue;
heap = atof(fr+1);
and = strstr(fr,"and");
if (and) free = atof(and+3);
fr = strstr(fr,"(" ); if (!fr) continue;
inc = atof(fr+1);
if (kind==1) continue;
TNamed *tn = (TNamed*)hash.FindObject(ts.Data());
if (!tn) {
tn = new TNamed(ts.Data(),"");
hash.Add(tn);
fNMakers++;
tn->SetUniqueID((UInt_t)fNMakers);
mArray.AddAtAndExpand(tn,fNMakers);
}
idx = tn->GetUniqueID();
return tn->GetName();
}
fclose(inp); inp = 0;
return 0;
}};
//_____________________________________________________
void GFHistManager::AddLegend(TLegend* leg, Int_t layer, Int_t histoNum)
{
// hist and layer must already exist
if(!this->CheckHistNum("AddLegend", layer, histoNum)) return;
TObjArray* legendsOfLayer = this->MakeLegends(layer);
TLegend* legend = (legendsOfLayer->GetSize() < histoNum ?
NULL : static_cast<TLegend*>(legendsOfLayer->At(histoNum)));
if(legend) {
this->Error("AddLegend", "legend exists, replacing it");
delete legend;
}
legend = leg;
legendsOfLayer->AddAtAndExpand(legend, histoNum);
if(layer < fCanArrays->GetEntriesFast()) {
this->Update(layer); // if canvas already drawn
}
}
//_____________________________________________________
TLegend* GFHistManager::AddLegend(Int_t layer, Int_t histoNum,
const char* header, Bool_t referAll)
{
// adds a legend referencing all hists in same pad 'histoNum' of layer
//
// FIXME: use help of other AddLegend method?
if(!this->CheckHistNum("AddLegend", layer, histoNum)) return NULL;
TObjArray* legendsOfLayer = this->MakeLegends(layer);
TLegend* legend = (legendsOfLayer->GetSize() <= histoNum ?
NULL : static_cast<TLegend*>(legendsOfLayer->At(histoNum)));
if(!legend) {
legend = new TLegend(fLegendX1, fLegendY1, fLegendX2, fLegendY2);
#if ROOT_VERSION_CODE < ROOT_VERSION(5,6,0)
if (TString(gStyle->GetName()) == "Plain") legend->SetBorderSize(1);
#endif
legendsOfLayer->AddAtAndExpand(legend, histoNum);
}
if(header) legend->SetHeader(header);
GFHistArray* hists = this->GetHistsOf(layer, histoNum);
TList* legendEntries = legend->GetListOfPrimitives();
if(referAll){
TIter histsIter(hists);
while(TObject* hist = histsIter.Next()){
Bool_t addNew = kTRUE;
TIter legEntrIter(legendEntries);
while(TLegendEntry* entry = static_cast<TLegendEntry*>(legEntrIter())){
if(hist == entry->GetObject()) {addNew = kFALSE; break;}
}
if(addNew) legend->AddEntry(hist, hist->GetName(), fgLegendEntryOption);
}
}
if(layer < fCanArrays->GetEntriesFast()) {
this->Update(layer); // if canvas already drawn
}
return legend;
}
//________________________________________________________
Bool_t GFHistManager::CheckHistNum(const char* method, Int_t layer,
Int_t histNum, Bool_t mayExpand)
{
// true if hist 'histNum' exists in 'layer'
// if(mayExpand == kTRUE) expands to this size if necessary! (default: kFALSE)
if(!this->CheckDepth(method, layer, mayExpand)) return kFALSE;
TObjArray * layerArr = static_cast<TObjArray*>(fHistArrays->At(layer));
if(histNum < 0) {
this->Warning("CheckHistNum", "histogram number %d requested!", histNum);
return kFALSE;
}
while(histNum >= layerArr->GetEntriesFast()){
if(mayExpand){
layerArr->AddAtAndExpand(new GFHistArray, layerArr->GetEntriesFast());
} else {
this->Warning("CheckHistNum", "layer %d has only %d histograms, number %d requested!",
layer, layerArr->GetEntriesFast(), histNum);
return kFALSE;
}
}
return kTRUE;
}
TObjArray* ProcessSummary(TObjArray* arrs, int icl, const char* pref)
{
// Process TObjArray (e.g. for set of pt bins) of TObjArray of KMCTrackSummary objects:
// pick the KMCTrackSummary for "summary class" icl (definition of acceptable track) and create
// graphs vs bin.
// These graphs are returned in new TObjArray
//
TString prefs = pref;
if (!gs) gs = new TF1("gs","gaus",-1,1);
//
int nb = arrs->GetEntriesFast();
TObjArray* sums = (TObjArray*) arrs->At(0);
int nclass = sums->GetEntriesFast();
if (icl>=nclass) {printf("summary set has %d classes only, %d requested\n",nclass,icl);return 0;}
//
KMCTrackSummary* sm = (KMCTrackSummary*)sums->At(icl);
//
TH1* h;
//
h = sm->GetHMCSigDCARPhi(); // MC resolution in transverse DCA
TGraphErrors * grSigD = 0;
if (h) {
grSigD = new TGraphErrors(nb);
grSigD->SetName(Form("%s%s",prefs.Data(),h->GetName()));
grSigD->SetTitle(Form("%s%s",prefs.Data(),h->GetTitle()));
}
//
TGraphErrors * grSigZ = 0;
h = sm->GetHMCSigDCAZ(); // MC resolution in Z DCA
if (h) {
grSigZ = new TGraphErrors(nb);
grSigZ->SetName(Form("%s%s",prefs.Data(),h->GetName()));
grSigZ->SetTitle(Form("%s%s",prefs.Data(),h->GetTitle()));
}
//
TGraphErrors * grSigAD = 0; // anaitical estimate for resolution in transverse DCA
{
grSigAD = new TGraphErrors(nb);
grSigAD->SetName(Form("%s%s",prefs.Data(),"sigmaDan"));
grSigAD->SetTitle(Form("%s%s",prefs.Data(),"#sigmaD an"));
}
//
TGraphErrors * grSigAZ = 0; // anaitical estimate for resolution in Z DCA
{
grSigAZ = new TGraphErrors(nb);
grSigAZ->SetName(Form("%s%s",prefs.Data(),"sigmaZan"));
grSigAZ->SetTitle(Form("%s%s",prefs.Data(),"#sigmaZ an"));
}
//
//
TGraphErrors * grSigPt = 0; // MC res. in pt
{
grSigPt = new TGraphErrors(nb);
grSigPt->SetName(Form("%s%s",prefs.Data(),"sigmaPt"));
grSigPt->SetTitle(Form("%s%s",prefs.Data(),"#sigmaPt"));
}
//
TGraphErrors * grSigAPt = 0; // analitycal res. in pt
{
grSigAPt = new TGraphErrors(nb);
grSigAPt->SetName(Form("%s%s",prefs.Data(),"sigmaPtan"));
grSigAPt->SetTitle(Form("%s%s",prefs.Data(),"#sigmaPt an"));
}
//
TGraphErrors * grEff = 0; // MC efficiency
{
grEff = new TGraphErrors(nb);
grEff->SetName(Form("%s_rate",prefs.Data()));
grEff->SetTitle(Form("%s Rate",prefs.Data()));
}
//
TGraphErrors * grUpd = 0; // number of Kalman track updates
{
grUpd = new TGraphErrors(nb);
grUpd->SetName(Form("%s_updCalls",prefs.Data()));
grUpd->SetTitle(Form("%s Updates",prefs.Data()));
}
//
for (int ib=0;ib<nb;ib++) {
sums = (TObjArray*) arrs->At(ib);
sm = (KMCTrackSummary*)sums->At(icl);
KMCProbe& prbRef = sm->GetRefProbe();
KMCProbe& prbAn = sm->GetAnProbe();
double pt = prbRef.Pt();
//
if (grSigAD) {
grSigAD->SetPoint(ib, pt,prbAn.GetSigmaY2()>0 ? TMath::Sqrt(prbAn.GetSigmaY2()) : 0.);
}
//
if (grSigAZ) {
grSigAZ->SetPoint(ib, pt,prbAn.GetSigmaZ2()>0 ? TMath::Sqrt(prbAn.GetSigmaZ2()) : 0.);
}
//
if (grSigAPt) {
double pts = TMath::Sqrt(prbAn.GetSigma1Pt2());
grSigAPt->SetPoint(ib, pt,pts>0 ? pts*pt : 0.);
}
//
if (grSigPt) {
h = sm->GetHMCSigPt();
h->Fit(gs,"0q");
grSigPt->SetPoint(ib, pt, gs->GetParameter(2));
grSigPt->SetPointError(ib, 0, gs->GetParError(2));
}
//
if (grSigD) {
h = sm->GetHMCSigDCARPhi();
h->Fit(gs,"0q");
grSigD->SetPoint(ib, pt,gs->GetParameter(2));
grSigD->SetPointError(ib, 0,gs->GetParError(2));
}
//
if (grSigZ) {
h = sm->GetHMCSigDCAZ();
h->Fit(gs,"0q");
grSigZ->SetPoint(ib, pt,gs->GetParameter(2));
grSigZ->SetPointError(ib, 0,gs->GetParError(2));
}
//
if (grEff) {
grEff->SetPoint(ib, pt,sm->GetEff());
grEff->SetPointError(ib, 0,sm->GetEffErr());
}
//
if (grUpd) {
grUpd->SetPoint(ib, pt,sm->GetUpdCalls());
grUpd->SetPointError(ib, 0, 0);
}
}
//
TObjArray* dest = new TObjArray();
dest->AddAtAndExpand(grSigAD,kSigAD);
dest->AddAtAndExpand(grSigAZ,kSigAZ);
dest->AddAtAndExpand(grSigAPt,kSigAPt);
dest->AddAtAndExpand(grSigD,kSigD);
dest->AddAtAndExpand(grSigZ,kSigZ);
dest->AddAtAndExpand(grSigPt,kSigPt);
dest->AddAtAndExpand(grEff,kEff);
dest->AddAtAndExpand(grUpd,kUpd);
//
if (!prefs.IsNull()) dest->SetName(pref);
return dest;
}
void compClusHitsMod2(int nev=-1)
{
const int kSplit=0x1<<22;
const int kSplCheck=0x1<<23;
//
gSystem->Load("libITSUpgradeBase");
gSystem->Load("libITSUpgradeSim");
gSystem->Load("libITSUpgradeRec");
gROOT->SetStyle("Plain");
AliCDBManager* man = AliCDBManager::Instance();
man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
man->SetSpecificStorage("GRP/GRP/Data",
Form("local://%s",gSystem->pwd()));
man->SetSpecificStorage("ITS/Align/Data",
Form("local://%s",gSystem->pwd()));
man->SetSpecificStorage("ITS/Calib/RecoParam",
Form("local://%s",gSystem->pwd()));
man->SetRun(0);
TH1F* hL0A = new TH1F("hL0A", "Layer 0, polar angle", 20, 0, TMath::PiOver2());
hL0A->SetDirectory(0);
hL0A->GetXaxis()->SetTitle("#alpha");
TH1F* hL0B = new TH1F("hL0B", "Layer 0, azimuthal angle", 20, 0, TMath::PiOver2());
hL0B->SetDirectory(0);
hL0B->GetXaxis()->SetTitle("#beta");
TH1F* hL1A = new TH1F("hL1A", "Layer 1, polar angle", 20, 0, TMath::PiOver2());
hL1A->SetDirectory(0);
hL1A->GetXaxis()->SetTitle("#alpha");
TH1F* hL1B = new TH1F("hL1B", "Layer 1, azimuthal angle", 20, 0, TMath::PiOver2());
hL1B->SetDirectory(0);
hL1B->GetXaxis()->SetTitle("#beta");
TH1F* hL2A = new TH1F("hL2A", "Layer 2, polar angle", 20, 0, TMath::PiOver2());
hL2A->SetDirectory(0);
hL2A->GetXaxis()->SetTitle("#alpha");
TH1F* hL2B = new TH1F("hL2B", "Layer 2, azimuthal angle", 20, 0, TMath::PiOver2());
hL2B->SetDirectory(0);
hL2B->GetXaxis()->SetTitle("#beta");
TH1F* hL3A = new TH1F("hL3A", "Layer 3, polar angle", 20, 0, TMath::PiOver2());
hL3A->SetDirectory(0);
hL3A->GetXaxis()->SetTitle("#alpha");
TH1F* hL3B = new TH1F("hL3B", "Layer 3, azimuthal angle", 20, 0, TMath::PiOver2());
hL3B->SetDirectory(0);
hL3B->GetXaxis()->SetTitle("#beta");
TH1F* hL4A = new TH1F("hL4A", "Layer 4, polar angle", 20, 0, TMath::PiOver2());
hL4A->SetDirectory(0);
hL4A->GetXaxis()->SetTitle("#alpha");
TH1F* hL4B = new TH1F("hL4B", "Layer 4, azimuthal angle", 20, 0, TMath::PiOver2());
hL4B->SetDirectory(0);
hL4B->GetXaxis()->SetTitle("#beta");
TH1F* hL5A = new TH1F("hL5A", "Layer 5, polar angle", 20, 0, TMath::PiOver2());
hL5A->SetDirectory(0);
hL5A->GetXaxis()->SetTitle("#alpha");
TH1F* hL5B = new TH1F("hL5B", "Layer 5, azimuthal angle", 20, 0, TMath::PiOver2());
hL5B->SetDirectory(0);
hL5B->GetXaxis()->SetTitle("#beta");
TH1F* hL6A = new TH1F("hL6A", "Layer 6, polar angle", 20, 0, TMath::PiOver2());
hL6A->SetDirectory(0);
hL6A->GetXaxis()->SetTitle("#alpha");
TH1F* hL6B = new TH1F("hL6B", "Layer 6, azimuthal angle", 20, 0, TMath::PiOver2());
hL6B->SetDirectory(0);
hL6B->GetXaxis()->SetTitle("#beta");
gAlice=NULL;
AliRunLoader* runLoader = AliRunLoader::Open("galice.root");
runLoader->LoadgAlice();
gAlice = runLoader->GetAliRun();
runLoader->LoadHeader();
runLoader->LoadKinematics();
runLoader->LoadRecPoints();
runLoader->LoadSDigits();
runLoader->LoadHits();
AliLoader *dl = runLoader->GetDetectorLoader("ITS");
AliGeomManager::LoadGeometry("geometry.root");
TObjArray algITS;
AliGeomManager::LoadAlignObjsFromCDBSingleDet("ITS",algITS);
AliGeomManager::ApplyAlignObjsToGeom(algITS);
//
AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE);
AliITSMFTClusterPix::SetGeom(gm);
//
AliITSURecoDet *its = new AliITSURecoDet(gm, "ITSinterface");
its->CreateClusterArrays();
//
Double_t xg1,yg1,zg1=0.,xg0,yg0,zg0=0.,tg0;
Double_t xExit,yExit,zExit,xEnt,yEnt,zEnt,tof1;
//
TTree *cluTree = 0x0;
TTree *hitTree = 0x0;
TClonesArray *hitList=new TClonesArray("AliITSMFTHit");
//
Float_t xyzClGloF[3];
Double_t xyzClGlo[3],xyzClTr[3];
Int_t labels[3];
int nLab = 0;
int nlr=its->GetNLayersActive();
int ntotev = (Int_t)runLoader->GetNumberOfEvents();
printf("N Events : %i \n",ntotev);
if (nev>0) ntotev = TMath::Min(nev,ntotev);
//
// output tree
TFile* flOut = TFile::Open("clInfo.root","recreate");
TTree* trOut = new TTree("clitsu","clitsu");
clSumm cSum;
trOut->Branch("evID", &cSum.evID ,"evID/I");
trOut->Branch("volID",&cSum.volID,"volID/I");
trOut->Branch("lrID", &cSum.lrID ,"lrID/I");
trOut->Branch("clID", &cSum.clID ,"clID/I");
trOut->Branch("nPix", &cSum.nPix ,"nPix/I");
trOut->Branch("nX" , &cSum.nX ,"nX/I");
trOut->Branch("nZ" , &cSum.nZ ,"nZ/I");
trOut->Branch("q" , &cSum.q ,"q/I");
trOut->Branch("pt" , &cSum.pt ,"pt/F");
trOut->Branch("eta" ,&cSum.eta ,"eta/F");
trOut->Branch("phi" , &cSum.phi ,"phi/F");
trOut->Branch("xyz", cSum.xyz, "xyz[3]/F");
trOut->Branch("dX" , &cSum.dX ,"dX/F");
trOut->Branch("dY" , &cSum.dY ,"dY/F");
trOut->Branch("dZ" , &cSum.dZ ,"dZ/F");
trOut->Branch("split",&cSum.split,"split/O");
trOut->Branch("prim", &cSum.prim, "prim/O");
trOut->Branch("pdg", &cSum.pdg, "pdg/I");
trOut->Branch("ntr", &cSum.ntr, "ntr/I");
trOut->Branch("alpha", &cSum.alpha, "alpha/F");
trOut->Branch("beta", &cSum.beta, "beta/F");
trOut->Branch("nRowPatt", &cSum.nRowPatt, "nRowPatt/I");
trOut->Branch("nColPatt", &cSum.nColPatt, "nColPatt/I");
TopDatabase DB;
for (Int_t iEvent = 0; iEvent < ntotev; iEvent++) {
printf("\n Event %i \n",iEvent);
runLoader->GetEvent(iEvent);
AliStack *stack = runLoader->Stack();
cluTree=dl->TreeR();
hitTree=dl->TreeH();
hitTree->SetBranchAddress("ITS",&hitList);
//
// read clusters
for (int ilr=nlr;ilr--;) {
TBranch* br = cluTree->GetBranch(Form("ITSRecPoints%d",ilr));
if (!br) {printf("Did not find cluster branch for lr %d\n",ilr); exit(1);}
br->SetAddress(its->GetLayerActive(ilr)->GetClustersAddress());
}
cluTree->GetEntry(0);
its->ProcessClusters();
//
// read hits
for(Int_t iEnt=0;iEnt<hitTree->GetEntries();iEnt++){//entries loop of the hits
hitTree->GetEntry(iEnt);
int nh = hitList->GetEntries();
for(Int_t iHit=0; iHit<nh;iHit++){
AliITSMFTHit *pHit = (AliITSMFTHit*)hitList->At(iHit);
int mcID = pHit->GetTrack();
//printf("MCid: %d %d %d Ch %d\n",iEnt,iHit, mcID, pHit->GetChip());
TClonesArray* harr = arrMCTracks.GetEntriesFast()>mcID ? (TClonesArray*)arrMCTracks.At(mcID) : 0;
if (!harr) {
harr = new TClonesArray("AliITSMFTHit"); // 1st encounter of the MC track
arrMCTracks.AddAtAndExpand(harr,mcID);
}
//
new ( (*harr)[harr->GetEntriesFast()] ) AliITSMFTHit(*pHit);
}
}
// return;
//
// compare clusters and hits
//
printf(" tree entries: %lld\n",cluTree->GetEntries());
//
for (int ilr=0;ilr<nlr;ilr++) {
AliITSURecoLayer* lr = its->GetLayerActive(ilr);
TClonesArray* clr = lr->GetClusters();
int nClu = clr->GetEntries();
//printf("Layer %d : %d clusters\n",ilr,nClu);
//
for (int icl=0;icl<nClu;icl++) {
AliITSMFTClusterPix *cl = (AliITSMFTClusterPix*)clr->At(icl);
int modID = cl->GetVolumeId();
//------------ check if this is a split cluster
int sInL = modID - gm->GetFirstChipIndex(ilr);
if (!cl->TestBit(kSplCheck)) {
cl->SetBit(kSplCheck);
// check if there is no other cluster with same label on this module
AliITSURecoSens* sens = lr->GetSensor(sInL);
int nclSn = sens->GetNClusters();
int offs = sens->GetFirstClusterId();
// printf("To check for %d (mod:%d) N=%d from %d\n",icl,modID,nclSn,offs);
for (int ics=0;ics<nclSn;ics++) {
AliITSMFTClusterPix* clusT = (AliITSMFTClusterPix*)lr->GetCluster(offs+ics); // access to clusters
if (clusT==cl) continue;
for (int ilb0=0;ilb0<3;ilb0++) {
int lb0 = cl->GetLabel(ilb0); if (lb0<=-1) break;
for (int ilb1=0;ilb1<3;ilb1++) {
int lb1 = clusT->GetLabel(ilb1); if (lb1<=-1) break;
if (lb1==lb0) {
cl->SetBit(kSplit);
clusT->SetBit(kSplit);
/*
printf("Discard clusters of module %d:\n",modID);
cl->Print();
clusT->Print();
*/
break;
}
}
}
}
}
//------------
const AliITSMFTSegmentationPix* segm = gm->GetSegmentation(ilr);
//
cl->GetGlobalXYZ(xyzClGloF);
int clsize = cl->GetNPix();
for (int i=3;i--;) xyzClGlo[i] = xyzClGloF[i];
const TGeoHMatrix* mat = gm->GetMatrixSens(modID);
if (!mat) {printf("failed to get matrix for module %d\n",cl->GetVolumeId());}
mat->MasterToLocal(xyzClGlo,xyzClTr);
//
int col,row;
segm->LocalToDet(xyzClTr[0],xyzClTr[2],row,col); // effective col/row
nLab = 0;
for (int il=0;il<3;il++) {
if (cl->GetLabel(il)>=0) labels[nLab++] = cl->GetLabel(il);
else break;
}
// find hit info
for (int il=0;il<nLab;il++) {
TClonesArray* htArr = (TClonesArray*)arrMCTracks.At(labels[il]);
//printf("check %d/%d LB %d %p\n",il,nLab,labels[il],htArr);
if (!htArr) {printf("did not find MChits for label %d ",labels[il]); cl->Print(); continue;}
//
int nh = htArr->GetEntriesFast();
AliITSMFTHit *pHit=0;
for (int ih=nh;ih--;) {
AliITSMFTHit* tHit = (AliITSMFTHit*)htArr->At(ih);
if (tHit->GetChip()!=modID) continue;
pHit = tHit;
break;
}
if (!pHit) {
printf("did not find MChit for label %d on module %d ",il,modID);
cl->Print();
htArr->Print();
continue;
}
//
pHit->GetPositionG(xg1,yg1,zg1);
pHit->GetPositionG0(xg0,yg0,zg0,tg0);
//
double txyzH[3],gxyzH[3] = { (xg1+xg0)/2, (yg1+yg0)/2, (zg1+zg0)/2 };
mat->MasterToLocal(gxyzH,txyzH);
double rcl = TMath::Sqrt(xyzClTr[0]*xyzClTr[0]+xyzClTr[1]*xyzClTr[1]);
double rht = TMath::Sqrt(txyzH[0]*txyzH[0]+txyzH[1]*txyzH[1]);
//
//Angles determination
pHit->GetPositionL(xExit,yExit,zExit,gm);
pHit->GetPositionL0(xEnt,yEnt,zEnt,tof1,gm);
Double_t dirHit[3]={(xExit-xEnt),(yExit-yEnt),(zExit-zEnt)};
/*double PG[3] = {(double)pHit->GetPXG(), (double)pHit->GetPYG(), (double)pHit->GetPZG()}; //Momentum at hit-point in Global Frame
double PL[3];
if (TMath::Abs(PG[0])<10e-7 && TMath::Abs(PG[1])<10e-7) {
pHit->Dump();
int lb = pHit->GetTrack();
stack->Particle(lb)->Print();
continue;
}
mat->MasterToLocalVect(PG,PL); //Momentum in local Frame
//printf(">> %e %e %e %e %e %e\n",PG[0],PL[0],PG[1],PL[1],PG[2],PL[2]);*/
Double_t alpha1 = TMath::ACos(TMath::Abs(dirHit[1])/TMath::Sqrt(dirHit[0]*dirHit[0]+dirHit[1]*dirHit[1]+dirHit[2]*dirHit[2])); //Polar Angle
Float_t alpha2 = (Float_t) alpha1; //convert to float
cSum.alpha = alpha2;
Double_t beta1;
beta1 = TMath::ATan2(dirHit[0],dirHit[2]); //Azimuthal angle, values from -Pi to Pi
Float_t beta2 = (Float_t) beta1;
cSum.beta = beta2;
if(ilr==0){
hL0A->Fill(alpha2);
hL0B->Fill(beta2);
}
if(ilr==1){
hL1A->Fill(alpha2);
hL1B->Fill(beta2);
}
if(ilr==2){
hL2A->Fill(alpha2);
hL2B->Fill(beta2);
}
if(ilr==3){
hL3A->Fill(alpha2);
hL3B->Fill(beta2);
}
if(ilr==4){
hL4A->Fill(alpha2);
hL4B->Fill(beta2);
}
if(ilr==5){
hL5A->Fill(alpha2);
hL5B->Fill(beta2);
}
if(ilr==6){
hL6A->Fill(alpha2);
hL6B->Fill(beta2);
}
GetHistoClSize(clsize,kDR,&histoArr)->Fill((rht-rcl)*1e4);
if (cl->TestBit(kSplit)) {
if (col%2) GetHistoClSize(clsize,kDTXoddSPL,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
else GetHistoClSize(clsize,kDTXevenSPL,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
GetHistoClSize(clsize,kDTZSPL,&histoArr)->Fill((txyzH[2]-xyzClTr[2])*1e4);
GetHistoClSize(0,kNPixSPL,&histoArr)->Fill(clsize);
}
if (col%2) GetHistoClSize(clsize,kDTXodd,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
else GetHistoClSize(clsize,kDTXeven,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
GetHistoClSize(clsize,kDTZ,&histoArr)->Fill((txyzH[2]-xyzClTr[2])*1e4);
GetHistoClSize(0,kNPixAll,&histoArr)->Fill(clsize);
//
cSum.evID = iEvent;
cSum.volID = cl->GetVolumeId();
cSum.lrID = ilr;
cSum.clID = icl;
cSum.nPix = cl->GetNPix();
cSum.nX = cl->GetNx();
cSum.nZ = cl->GetNz();
cSum.q = cl->GetQ();
cSum.split = cl->TestBit(kSplit);
cSum.dX = (txyzH[0]-xyzClTr[0])*1e4;
cSum.dY = (txyzH[1]-xyzClTr[1])*1e4;
cSum.dZ = (txyzH[2]-xyzClTr[2])*1e4;
cSum.nRowPatt = cl-> GetPatternRowSpan();
cSum.nColPatt = cl-> GetPatternColSpan();
DB.AccountTopology(*cl, cSum.dX, cSum.dZ, cSum.alpha, cSum.beta);
GetHistoClSize(clsize,kDR,&histoArr)->Fill((rht-rcl)*1e4);
if (cl->TestBit(kSplit)) {
if (col%2) GetHistoClSize(clsize,kDTXoddSPL,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
else GetHistoClSize(clsize,kDTXevenSPL,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
GetHistoClSize(clsize,kDTZSPL,&histoArr)->Fill((txyzH[2]-xyzClTr[2])*1e4);
GetHistoClSize(0,kNPixSPL,&histoArr)->Fill(clsize);
}
if (col%2) GetHistoClSize(clsize,kDTXodd,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
else GetHistoClSize(clsize,kDTXeven,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
GetHistoClSize(clsize,kDTZ,&histoArr)->Fill((txyzH[2]-xyzClTr[2])*1e4);
GetHistoClSize(0,kNPixAll,&histoArr)->Fill(clsize);
//
cSum.evID = iEvent;
cSum.volID = cl->GetVolumeId();
cSum.lrID = ilr;
cSum.clID = icl;
cSum.nPix = cl->GetNPix();
cSum.nX = cl->GetNx();
cSum.nZ = cl->GetNz();
cSum.q = cl->GetQ();
cSum.split = cl->TestBit(kSplit);
cSum.dX = (txyzH[0]-xyzClTr[0])*1e4;
cSum.dY = (txyzH[1]-xyzClTr[1])*1e4;
cSum.dZ = (txyzH[2]-xyzClTr[2])*1e4;
cSum.nRowPatt = cl-> GetPatternRowSpan();
cSum.nColPatt = cl-> GetPatternColSpan();
int label = cl->GetLabel(0);
TParticle* part = 0;
if (label>=0 && (part=stack->Particle(label)) ) {
cSum.pdg = part->GetPdgCode();
cSum.eta = part->Eta();
cSum.pt = part->Pt();
cSum.phi = part->Phi();
cSum.prim = stack->IsPhysicalPrimary(label);
}
cSum.ntr = 0;
for (int ilb=0;ilb<3;ilb++) if (cl->GetLabel(ilb)>=0) cSum.ntr++;
for (int i=0;i<3;i++) cSum.xyz[i] = xyzClGloF[i];
//
trOut->Fill();
/*
if (clsize==5) {
printf("\nL%d(%c) Mod%d, Cl:%d | %+5.1f %+5.1f (%d/%d)|H:%e %e %e | C:%e %e %e\n",ilr,cl->TestBit(kSplit) ? 'S':'N',
modID,icl,(txyzH[0]-xyzClTr[0])*1e4,(txyzH[2]-xyzClTr[2])*1e4, row,col,
gxyzH[0],gxyzH[1],gxyzH[2],xyzClGlo[0],xyzClGlo[1],xyzClGlo[2]);
cl->Print();
pHit->Print();
//
double a0,b0,c0,a1,b1,c1,e0;
pHit->GetPositionL0(a0,b0,c0,e0);
pHit->GetPositionL(a1,b1,c1);
float cloc[3];
cl->GetLocalXYZ(cloc);
printf("LocH: %e %e %e | %e %e %e\n",a0,b0,c0,a1,b1,c1);
printf("LocC: %e %e %e | %e %e %e\n",cloc[0],cloc[1],cloc[2],xyzClTr[0],xyzClTr[1],xyzClTr[2]);
}
*/
//
}
}
}
// layerClus.Clear();
//
arrMCTracks.Delete();
}//event loop
//
DB.EndAndSort();
DB.SetThresholdCumulative(0.95);
cout << "Over threshold: : "<< DB.GetOverThr()<<endl;
DB.Grouping(10,10);
DB.PrintDB("Database1.txt");
flOut->cd();
trOut->Write();
delete trOut;
flOut->Close();
flOut->Delete();
DrawReport("clinfo.ps",&histoArr);
TFile* flDB = TFile::Open("TopologyDatabase.root", "recreate");
flDB->WriteObject(&DB,"DB","kSingleKey");
flDB->Close();
delete flDB;
TCanvas* cnv123 = new TCanvas("cnv123","cnv123");
cnv123->Divide(1,2);
cnv123->Print("anglesdistr.pdf[");
cnv123->cd(1);
hL0A->Draw();
cnv123->cd(2);
hL0B->Draw();
cnv123->Print("anglesdistr.pdf");
cnv123->cd(1);
hL1A->Draw();
cnv123->cd(2);
hL1B->Draw();
cnv123->Print("anglesdistr.pdf");
cnv123->cd(1);
hL2A->Draw();
cnv123->cd(2);
hL2B->Draw();
cnv123->Print("anglesdistr.pdf");
cnv123->cd(1);
hL3A->Draw();
cnv123->cd(2);
hL3B->Draw();
cnv123->Print("anglesdistr.pdf");
cnv123->cd(1);
hL4A->Draw();
cnv123->cd(2);
hL4B->Draw();
cnv123->Print("anglesdistr.pdf");
cnv123->cd(1);
hL5A->Draw();
cnv123->cd(2);
hL5B->Draw();
cnv123->Print("anglesdistr.pdf");
cnv123->cd(1);
hL6A->Draw();
cnv123->cd(2);
hL6B->Draw();
cnv123->Print("anglesdistr.pdf");
cnv123->Print("anglesdistr.pdf]");
//
}
