//________________________________________________________ bool GFOverlay::OpenFilesLegends(const char *fileLegendList) { bool allOk = true; TObjArray *fileLegPairs = TString(fileLegendList).Tokenize(","); for (Int_t iF = 0; iF < fileLegPairs->GetEntriesFast(); ++iF) { TObjArray *aFileLegPair = TString(fileLegPairs->At(iF)->GetName()).Tokenize("="); const char *legend = ""; if (aFileLegPair->GetEntriesFast() >= 2) { if (aFileLegPair->GetEntriesFast() > 2) { ::Error("GFOverlay::OpenFilesLegends", "File-legend pair %s: %d (>2) '=' separated parts!", fileLegPairs->At(iF)->GetName(), aFileLegPair->GetEntriesFast()); } legend = aFileLegPair->At(1)->GetName(); } else if (aFileLegPair->GetEntriesFast() < 1) { continue; // empty: should report error? } // else if (aFileLegPair->GetEntriesFast() == 1): That's OK, use empty legend. TFile *file = TFile::Open(aFileLegPair->At(0)->GetName()); if (!file) { ::Error("GFOverlay::OpenFilesLegends", "Skip file-legend pair %s due to opening problems!", fileLegPairs->At(iF)->GetName()); allOk = false; } else { fFiles.Add(file); fLegends.Add(new TObjString(legend)); } delete aFileLegPair; } delete fileLegPairs; return allOk; }
//______________________________________________________________________________ void DrawHighlightFragments(const TRsnGroup *rsng, const char *whichtag = "") { if (!rsng || !rsng->GetListOfFragments()) return; tagname = whichtag; group = rsng; TObjArray *fragments = group->GetListOfFragments(); gr = new TGraph(fragments->GetEntriesFast()); for (Int_t i = 0; i < fragments->GetEntriesFast(); i++) { TRsnFragment *frag = group->FragmentAt(i); if (frag) gr->SetPoint(i, frag->GetMean(), 0.91); } // TString cmd = TString::Format("(TGraph *)0x%lx", (ULong_t)g); // Printf("cmd = %s", cmd.Data()); // cmd = TString::Format("((TRsnGroup *)0x%lx)->HighlightFragment(%s)", // (ULong_t)this, cmd.Data()); // Printf("cmd = %s", cmd.Data()); // TExec *ex = new TExec("ex", cmd.Data()); TExec *ex = new TExec("ex", "HighlightFragment()"); gr->GetListOfFunctions()->Add(ex); gr->SetHighlight(kTRUE); gr->SetTitle(); gr->SetMarkerStyle(20); gr->GetYaxis()->SetTickLength(0.0); gr->SetBit(kCanDelete); gr->Draw("AP"); gr->GetXaxis()->SetTitle("bla_bla"); }
//________________________________________________________ void GFOverlay::CreateFillMeanRms(const TObjArray &hists, Int_t layer, const char *dirName, std::vector<TH1*> &meanHists, std::vector<TH1*> &rmsHists) const { // fill mean/rms from hists into the corresponding meanHists/rmsHists // if these are empty, create one hist for each slot of hists (even for empty ones!) if (hists.IsEmpty()) return; TH1 *h1 = 0; for (Int_t iH = 0; !h1 && iH < hists.GetEntriesFast(); ++iH) { h1 = static_cast<TH1*>(hists[iH]); } if (!h1 || h1->GetDimension() > 1) return; // only for 1D hists if (meanHists.empty()) { // create mean/RMS hists if not yet done const Float_t min = h1->GetXaxis()->GetXmin()/3.; const Float_t max = h1->GetXaxis()->GetXmax()/3.; const Int_t nBins = h1->GetNbinsX()/2; for (Int_t iHist = 0; iHist < hists.GetEntriesFast(); ++iHist) { TH1 *hMean = new TH1F(Form("mean%d_%d", layer, iHist), Form("%s: mean", dirName), nBins, min, max); meanHists.push_back(hMean); TH1 *hRms = new TH1F(Form("rms%d_%d", layer, iHist), Form("%s: RMS", dirName), nBins, 0., max); rmsHists.push_back(hRms); } } // now fill mean and rms hists for (Int_t iHist = 0; iHist < hists.GetEntriesFast(); ++iHist) { TH1 *h = static_cast<TH1*>(hists[iHist]); if (!h) continue; meanHists[iHist]->Fill(h->GetMean()); rmsHists[iHist]->Fill(h->GetRMS()); } }
void Output::fixLeafOffsets( TBranch * b) { // recalculates the addresses for all the leaves. // // when constructing a branch with containing a variable length array with the index // variable in the same branch it is not possible to specify the span of the index variable // This span defaults to zero. When the addresses are asigned to the various leaves in the branch // it calculates the size of the particular leaf (variable length array) in the buffer by looking // at the span of the index variable - 0 in this case! using the method TLeaf::GetLen(). // The following code shoudl be applied to the branch after the spans of the index variables have been // specified manually using the TLeaf::SetMaximum method. This time the GetLen method calculates the correct offset. TObjArray * leaves = b->GetListOfLeaves(); char * addr = b->GetAddress(); int offset = 0; int nleaves = leaves->GetEntriesFast(); // loop over the leaves: for( int i =0; i < nleaves; ++i) { TLeaf * leaf = (TLeaf *)leaves->UncheckedAt(i); leaf->SetAddress( addr + offset ); int oldOffset = leaf->GetOffset(); leaf->SetOffset( offset ); //std::cout << " offset changed from : " << oldOffset << " to " << offset << std::endl; TLeaf * index = leaf->GetLeafCount(); int nelements = 1; if( index ) { nelements = index->GetMaximum(); // deal with variable length arrays } else { nelements = leaf->GetLenStatic(); // deal with single variables and fixed length arrays } offset += leaf->GetLenType() * nelements; } }
Bool_t RecoParamWithTPCDistortions(AliCDBManager *man) { // check methods exist if (!AliRecoParam::Class()->GetMethodAny("SuggestRunEventSpecie")) return kFALSE; if (!AliTPCRecoParam::Class()->GetMethodAny("GetUseCorrectionMap")) return kFALSE; // get event specie from GRP AliCDBEntry *grpe = man->Get("GRP/GRP/Data"); if (!grpe) return kFALSE; AliGRPObject *grp = (AliGRPObject *)grpe->GetObject(); AliRecoParam::EventSpecie_t evs = AliRecoParam::SuggestRunEventSpecie(grp->GetRunType(), grp->GetBeamType(), grp->GetLHCState()); // get TPC RecoParam for event specie AliCDBEntry *pare = man->Get("TPC/Calib/RecoParam"); if (!pare) return kFALSE; TObjArray *parl = (TObjArray *)pare->GetObject(); AliTPCRecoParam *par = NULL; for (Int_t i = parl->GetEntriesFast(); i--;) { AliTPCRecoParam *p = (AliTPCRecoParam *)parl->UncheckedAt(i); if (!p || !(p->GetEventSpecie() & evs)) continue; par = p; break; } // check if use correction map if (!par->GetUseCorrectionMap()) return kFALSE; return kTRUE; }
// ______________________________________________________________________________________ void SaveCanvas(const Char_t* name, Bool_t isNice = kTRUE) { // -- Write out canvas gSystem->Exec(Form("mkdir -p results/nice/%s/png", name)); gSystem->Exec(Form("mkdir -p results/nice/%s/pdf", name)); gSystem->Exec(Form("mkdir -p results/nice/%s/eps", name)); gSystem->Exec(Form("mkdir -p results/nice/%s/gif", name)); gSystem->Exec(Form("mkdir -p results/nice/%s/root", name)); if (isNice) { gSystem->Exec(Form("mkdir -p results/nice/pdf")); gSystem->Exec(Form("mkdir -p results/nice/png")); } // ----------------------------------------------------- for (Int_t idx = 0; idx < canA.GetEntriesFast() ; ++idx) { TCanvas* c = static_cast<TCanvas*>(canA.At(idx)); if (!c) continue; c->SaveAs(Form("results/nice/%s/png/%s.png", name, c->GetName())); c->SaveAs(Form("results/nice/%s/eps/%s.eps", name, c->GetName())); c->SaveAs(Form("results/nice/%s/gif/%s.gif", name, c->GetName())); c->SaveAs(Form("results/nice/%s/pdf/%s.pdf", name, c->GetName())); c->SaveAs(Form("results/nice/%s/root/%s.C", name, c->GetName())); c->SaveAs(Form("results/nice/%s/root/%s.root", name, c->GetName())); if (isNice) { c->SaveAs(Form("results/nice/pdf/%s.pdf", c->GetName())); c->SaveAs(Form("results/nice/png/%s.png", c->GetName())); } } }
Int_t CountChargedinScint() { Int_t ncharged = 0; TObjArray* tracks = gGeoManager->GetListOfTracks(); for(Int_t i=0,l=tracks->GetEntriesFast();i<l;++i) { TVirtualGeoTrack* track = (TVirtualGeoTrack*)tracks->At(i); //track->Print(); Int_t pdg = track->GetPDG(); Double_t charge = TDatabasePDG::Instance()->GetParticle(pdg)->Charge(); if( charge == 0 ) continue; Double_t x,y,z,t; TGeoNode* lastnode = NULL; for(Int_t j=0,lp=track->GetNpoints();j<lp;++j) { track->GetPoint(j,x,y,z,t); TGeoNode* node = gGeoManager->FindNode(x,y,z); if(! node ) continue; //node->Print(); if( lastnode == node ) continue; lastnode = node; //is scintillator ? //std::cout << node->GetMedium()->GetMaterial()->GetZ() << std::endl; if(node->GetMedium()->GetMaterial()->GetZ() == 1) ++ncharged; } //std::cout << "charge:" << ncharged << std::endl; } //std::cout << ncharged << std::endl; return ncharged; }
//________________________________________________________ Int_t GFHistManager::GetNumHistsOf(Int_t layer) { if(!this->CheckDepth("GetNumHistsOf", layer, kFALSE)) return 0; TObjArray* layerHists = static_cast<TObjArray*>(fHistArrays->At(layer)); if(layerHists) return layerHists->GetEntriesFast(); return 0; }
void PublicationHisto(TString config=""){ //gROOT->SetStyle("Plain"); gROOT->ForceStyle(); gROOT->ProcessLine(".x /home/aran/.rootlogon.C"); gStyle->SetPadBottomMargin(.160); // Need this for subscripts gStyle->SetPadTopMargin(.08); TEnv *params = new TEnv("PubHisto"); params->ReadFile (config, kEnvChange); TString type=params->GetValue("Histo.Type", "PublicationHisto"); if (type != "PublicationHisto"){ printf(" Must have Histo.Type: PublicationHisto in config file"); return; } // Fetch the histos from the different files: TString hname=params->GetValue("Histo.Name", "BOGUSNAME"); TObjArray sameHistos; if (hname == "3"){// ok this means we want to add 3 histos TString h1=params->GetValue("Histo.1.Name", "BOGUS_H1"); TString h2=params->GetValue("Histo.2.Name", "BOGUS_H2"); TString h3=params->GetValue("Histo.3.Name", "BOGUS_H3"); printf("Adding histos: %s, %s, %s \n",h1.Data(),h2.Data(), h3.Data()); TObjArray sameHistos = GetThreeSameHistos(h1,h2,h3,params); } else {// normal case TObjArray sameHistos = GetSameHistos(hname,params); } // Plot them: printf (" Found %3i histos \n",sameHistos.GetEntriesFast()); TCanvas *c1 = new TCanvas("c1","PubHist"); PlotPubHisto(sameHistos,params); TString outfile=params->GetValue("Output.File", "dummy.eps"); c1->SaveAs(outfile.Data()); }
int compareFileAges(const char* newestCandidate, const char* filesToCompare) { Long_t dummy = 0; Long_t candidateTime = 0; Long_t comparisonTime = 0; int found = !gSystem->GetPathInfo(newestCandidate, &dummy, &dummy, &dummy, &candidateTime); //cout << newestCandidate << ": " << candidateTime << endl; // If the first file is not found, return 1 if(!found) return 1; // Separate files in the list into an array TObjArray* compareList = TString(filesToCompare).Tokenize(" "); // Go through the array for (Int_t iFile = 0; iFile < compareList->GetEntriesFast(); ++iFile) { found = !gSystem->GetPathInfo(compareList->At(iFile)->GetName(), &dummy, &dummy, &dummy, &comparisonTime); //cout << compareList->At(iFile)->GetName() << ": " << comparisonTime << endl; // If the first file doesn't have the biggest modification time, return 1 if(found && candidateTime <= comparisonTime) return 1; } // The first file had the biggest modification time: return 0 return 0; }
// This piece of code is borrowed from Argo written by Nathaniel Tagg std::vector<std::string> DataFetcher::FindLeavesOfType(std::string pattern) { /// Look in the tree and try to find a leaf element that matches 'pattern'. /// Return the full name of that leaf. std::vector<std::string> leaf_names; // Strip whitespace from pattern. pattern.erase(std::remove_if(pattern.begin(), pattern.end(), ::isspace), pattern.end()); TObjArray * list = tree_->GetListOfLeaves(); for (int i = 0; i < list->GetEntriesFast(); ++i) { TObject * o = list->At(i); TLeaf * leaf = (TLeaf *) o; std::string name = leaf->GetTypeName(); // Strip whitespace from pattern. name.erase(std::remove_if(name.begin(), name.end(), ::isspace), name.end()); size_t found = name.find(pattern); if (found != std::string::npos) { // Return this match. leaf_names.push_back(leaf->GetName()); } } return leaf_names; }
void GetHitsCoor(TObject *its, Int_t mod, TObjArray & histos, Int_t subd,Bool_t verb){ TH2F *h2=(TH2F*)histos.At(1+subd*9); TH1F *h1=(TH1F*)histos.At(4+subd*9); TH1F *ener=(TH1F*)histos.At(8+subd*9); IlcTARGET *TARGET= (IlcTARGET*)its; IlcTARGETmodule *modu = TARGET->GetModule(mod); TObjArray *fHits = modu->GetHits(); Int_t nhits = fHits->GetEntriesFast(); if(nhits>0){ if(verb){ cout<<"-------------------------------------------------------"<<endl; cout<<"Number of HTARGET for module "<<mod<<": "<<nhits<<endl; } for (Int_t hit=0;hit<nhits;hit++) { IlcTARGEThit *iHit = (IlcTARGEThit*) fHits->At(hit); if(!iHit->StatusEntering()){ Float_t x=iHit->GetXG(); Float_t y=iHit->GetYG(); Float_t z=iHit->GetZG(); Float_t edep=iHit->GetIonization()*1000000; h2->Fill(x,y); h1->Fill(z); ener->Fill(edep); if(verb){ cout<<"hit # "<<hit<<" Global coordinates "<<x<<" "<<y<<" "<<z<<endl; cout<<"track # "<<iHit->GetTrack()<<" energy deposition (KeV)= "; cout<<edep<<endl; } } } } }
GeoHandler& GeoHandler::i_collect(const TGeoNode* current, int level, Region rg, LimitSet ls) { TGeoVolume* volume = current->GetVolume(); TObjArray* nodes = volume->GetNodes(); int num_children = nodes ? nodes->GetEntriesFast() : 0; Volume vol(volume); Region region = vol.region(); LimitSet limits = vol.limitSet(); if ( m_propagateRegions ) { if ( !region.isValid() && rg.isValid() ) { region = rg; vol.setRegion(region); } if ( !limits.isValid() && ls.isValid() ) { limits = ls; vol.setLimitSet(limits); } } (*m_data)[level].insert(current); //printf("GeoHandler: collect level:%d %s\n",level,current->GetName()); if (num_children > 0) { for (int i = 0; i < num_children; ++i) { TGeoNode* node = (TGeoNode*) nodes->At(i); i_collect(node, level + 1, region, limits); } } return *this; }
vector<int> inputEMAP(vector<int> compVar, vector<int> compIdx){ vector<string> lines; std::string line; lines.clear(); std::ifstream infile(gl_emap, std::ios_base::in); if (!infile) { cout<<"Cannot open file "<<gl_emap<<endl; return false; } while(getline(infile, line, '\n')) { /* string dummy; //0 string crate; //1 string slot; //2 string tb; //3 string dcc; //4 string spigot; //5 string fiber; //6 string fiberchan; //7 string subdet; //8 string ieta; //9 string iphi; //10 string depth; //11 */ TString conv = TString(line.c_str()); TObjArray* aline = conv.Tokenize(" "); bool foundIt = true; for(int idx=0; idx<compVar.size() && foundIt; idx++){ TString s = ((TObjString*)(aline->At(compIdx[idx])))->GetString(); if( compVar[idx] != atoi(s.Data())) foundIt = false; } if(foundIt){ vector<int> found; for(int l=0; l<aline->GetEntriesFast(); l++){ TString s = ((TObjString*)(aline->At(l)))->GetString(); if(l!=3 && l!=8) found.push_back(atoi(s.Data())); else{ if(l==3){ if(s==TString("t")) found.push_back(0); else if(s==TString("b")) found.push_back(1); } if(l==8){ if(s==TString("HB")) found.push_back(0); else if(s==TString("HE")) found.push_back(1); else if(s==TString("HF")) found.push_back(2); else if(s==TString("HO")) found.push_back(3); } } } return found; } } vector<int> notFound; return notFound; }
//________________________________________________________ bool GFOverlay::KeyContainsListMember(const TString &key, const TObjArray &list) const { for (Int_t i = 0; i < list.GetEntriesFast(); ++i) { if (key.Contains(list[i]->GetName())) return true; } return false; }
//________________________________________________________ void GFHistManager::Print(const char* filename, Bool_t add) { // print all layers of histograms to ps-file 'filename' // if 'add == true' puts '(' or ')' only if 'filename' ends with it, // e.g. if i is loop variable // GFHistManager *man = ...; // TString name("XXX.ps"); // if(i == 0) man->Print(name + '('); // else if(i == last) man->Print(name + ')'); // else man->Print(name, kTRUE); const Bool_t rootIsBatch = gROOT->IsBatch(); if(fBatch){ gROOT->SetBatch(); for(Int_t i = 0; i < fDepth; ++i){ this->DrawReally(i); } } gROOT->SetBatch(rootIsBatch); TObjArray cans; TIter canArrayIter(fCanArrays); while(TObjArray* canArray = static_cast<TObjArray*>(canArrayIter.Next())){ cans.AddAll(canArray); } const Int_t nCans = cans.GetEntriesFast(); if(nCans == 1) { cans.At(0)->Print(filename); return; } TString plainName(filename); const Bool_t starting = plainName.EndsWith("("); if(starting) { const Ssiz_t ind = plainName.Last('('); plainName.Remove(ind); // plainName.ReplaceAll("(", ""); } const Bool_t ending = plainName.EndsWith(")"); if(ending) { const Ssiz_t ind = plainName.Last(')'); plainName.Remove(ind); // plainName.ReplaceAll(")", ""); } for(Int_t i = 0; i < nCans; ++i){ if(i == 0 && !ending && (!add || starting)) { cans.At(i)->Print(plainName + "("); } else if(i == nCans - 1 && !starting && (!add || ending)) { cans.At(i)->Print(plainName + ")"); } else { cans.At(i)->Print(plainName); } } }
void read_trigger_thresholds() { // Load libraries gROOT->Macro("loadMuDst.C"); gROOT->Macro("LoadLogger.C"); gSystem->Load("StTpcDb"); gSystem->Load("StDetectorDbMaker"); gSystem->Load("StDbUtilities"); gSystem->Load("StMcEvent"); gSystem->Load("StMcEventMaker"); gSystem->Load("StDaqLib"); gSystem->Load("StEmcRawMaker"); gSystem->Load("StEmcADCtoEMaker"); gSystem->Load("StEpcMaker"); gSystem->Load("StEmcSimulatorMaker"); gSystem->Load("StDbBroker"); gSystem->Load("St_db_Maker"); gSystem->Load("StEEmcUtil"); gSystem->Load("StEEmcDbMaker"); gSystem->Load("StTriggerUtilities"); ifstream in("test.out"); assert(in); in.seekg(0,ios::end); streampos length = in.tellg(); in.seekg(0,ios::beg); char* buffer = new char[length]; in.read(buffer,length); in.close(); TBufferFile buf(TBuffer::kRead); buf.SetBuffer(buffer,length,kFALSE); TObjArray* a = 0; buf >> a; a->Print(); cout << "Total entries: " << a->GetEntriesFast() << endl; for (int i = 0; i < a->GetEntriesFast(); ++i) { StTriggerThreshold* th = (StTriggerThreshold*)a->At(i); th->print(); } }
void collectContours(map<string,TGraph2D *>& m_graphs, const vector<string>& keys, map<string,double>& m_contourlevels, map<string,TList *>& m_contours) { cout << "CollectContours" << endl; TCanvas *canv = new TCanvas("dummy","dummy",100,100); //canv->Divide(3,2); std::cout << "keys.size() = " << keys.size() << std::endl; //process TGraph2Ds into contours at levels m_contourlevels for (size_t i=0; i<keys.size(); i++) { double clev = m_contourlevels[keys[i]]; TGraph2D *gr2d = m_graphs[keys[i]]; std::cout << "gr2d = " << gr2d << std::endl; std::cout << "gr2d->GetN() = " << gr2d->GetN() << std::endl; if (gr2d && (gr2d->GetN() > 0)) { gr2d->GetHistogram()->SetContour(1, &clev); //canv->cd(i+1); cout << "drawing... " << endl; gr2d->Draw("CONT LIST"); // it's stupid, but only "CONT" will generate the list gPad->Update(); TObjArray *contours = (TObjArray *)gROOT->GetListOfSpecials()->FindObject("contours"); assert(contours); TList *newlist = 0; for (int ci=0; ci<contours->GetEntriesFast(); ci++) { TList *contLevel = (TList*)contours->At(ci); printf("%s: Contour %d has %d Graphs\n", keys[i].c_str(), ci, contLevel->GetSize()); if (contLevel->GetSize()) { assert(contLevel->First()); if (!newlist) newlist = new TList(); TGraph *curv = (TGraph*)(contLevel->First()); for (int j=0; j<contLevel->GetSize(); j++) { newlist->Add((TGraph *)(curv->Clone())); curv=(TGraph *)(contLevel->After(curv)); } } } // contour loop cout << "Inserting contour list for "<< keys[i] << " newlist="<<newlist<<endl; m_contours[keys[i]] = newlist; } // if (gr2d) } // key loop //delete canv; } // collectContours
void InitSummaryTrending(TTree * tree){ // // Init drawing for the <detector> QA // Detector specific qaConfig() has to be called before invoking this function // 0.) Make descriptor // 1.) Make default canvas - addopt canvas width to the number of entries to draw // 3.) compute detector status graphs // // 0.) Make descriptor // TLatex *latex= new TLatex; latex->SetX(0.11); latex->SetY(0.8); latex->SetTextSize(0.03); descriptionQA = GetTexDescription(latex); // // 1.) Make default canvas - addopt canvas width to the number of entries to draw // TGraphErrors *gr = (TGraphErrors*) TStatToolkit::MakeGraphSparse(tree,"resolution:tagID",""); Int_t numberOfTags = gr->GetN(); cout<<"number of graph entries: "<<numberOfTags<<endl; double SpaceForLegend = 0.; Int_t canvas_width = SpaceForLegend + (numberOfTags+5)*30; Int_t canvas_height = 600; if ( canvas_width>kMaxCanvasWidth) canvas_width=kMaxCanvasWidth; canvasQA = new TCanvas("canvasQA","canvasQA",canvas_width,canvas_height); canvasQA->SetGrid(3); canvasQA->cd(); gPad->SetTicks(1,2); // canvasQA->SetRightMargin(SpaceForLegend/canvas_width); double leftlegend = 1 - 180./canvasQA->GetWw(); double rightlegend = 1 - 10./canvasQA->GetWw(); // // 2.) process config file qaConfig.C to initialize status aliases (outliers etc.), status bar criteria, status lines, ... // TString sStatusbarVars = statusDescription[0]; TString sStatusbarNames = statusDescription[1]; TString sCriteria = statusDescription[2]; cout << "sStatusbarVars = " << sStatusbarVars.Data() << endl; cout << "sCriteria = " << sCriteria.Data() << endl; // // 3.) compute detector status graphs // TObjArray* oaStatusbarVars = sStatusbarVars.Tokenize(";"); TObjArray* oaStatusbarNames = sStatusbarNames.Tokenize(";"); oaMultGr = new TObjArray(); int igr=0; for (Int_t vari=oaStatusbarVars->GetEntriesFast()-1; vari>=0; vari--){ // invert the order of the status graphs TString sVar = Form("%s:tagID", oaStatusbarVars->At(vari)->GetName()); //e.g. -> dcar:run oaMultGr->Add( TStatToolkit::MakeStatusMultGr(tree, sVar.Data(), "", sCriteria.Data(), igr) ); TString sYtitle = oaStatusbarNames->At(vari)->GetName(); // set better name for y axis of statuspad ((TMultiGraph*) oaMultGr->At(igr))->SetTitle(sYtitle.Data()); igr++; } }
//________________________________________________________ TCanvas* GFHistManager::GetCanvas(Int_t layer, Int_t number) { // after draw!! if(!fCanArrays || fCanArrays->GetEntriesFast() <= layer) return NULL; TObjArray* cans = static_cast<TObjArray*>(fCanArrays->At(layer)); if(cans && cans->GetEntriesFast() > number){ return static_cast<TCanvas*>(cans->At(number)); } return NULL; }
void ResetDeleteBranches(TTree* tree) { TObjArray* branches = tree->GetListOfBranches(); Int_t nb = branches->GetEntriesFast(); for (Int_t i = 0; i < nb; ++i) { TBranch* br = (TBranch*) branches->UncheckedAt(i); if (br->InheritsFrom(TBranchElement::Class())) { ((TBranchElement*) br)->ResetDeleteObject(); } } }
/** * Add distributions from other experiments to stacks * * @param name Name of current bin * @param i Index of current bin * @param sNN Center of mass energy * @param allALICE Stack of ALICE data * @param allCMS Stack of CMS data * @param alice Possible ALICE result on return * @param cms Possible CMS result on return */ void Other2Stack(const TString& name, Int_t i, UShort_t sNN, TMultiGraph* allALICE, TMultiGraph* allCMS, TGraph*& alice, TGraph*& cms) { if (!allALICE && !allCMS) return; TString tmp(name); tmp.ReplaceAll("p", "+"); tmp.ReplaceAll("m", "-"); tmp.ReplaceAll("_", " "); tmp.ReplaceAll("d", "."); TObjArray* tokens = tmp.Tokenize(" "); if (!tokens || tokens->GetEntriesFast() < 2) { Error("Other2Stack", "Failed to decode eta range from %s", name.Data()); if (tokens) tokens->Delete(); return; } Double_t eta1 = static_cast<TObjString*>(tokens->At(0))->String().Atof(); Double_t eta2 = static_cast<TObjString*>(tokens->At(1))->String().Atof(); tokens->Delete(); if (TMath::Abs(eta2+eta1) > 1e-3) { // Not symmetric bin // Info("Other2Stack", "bin [%f,%f] is not symmetric (%f)", // eta1, eta2, TMath::Abs(eta2-eta1)); return; } Double_t aEta = TMath::Abs(eta1); Int_t open, closed; Double_t factor; Float_t size; BinAttributes(i, open, closed, size, factor); if (allALICE) { TGraphAsymmErrors* g = GetOther(1, aEta, sNN, factor); if (g) { g->SetMarkerStyle(closed); g->SetMarkerColor(kColorALICE); g->SetMarkerSize(size); allALICE->Add(g, "p same"); alice = g; } } if (allCMS) { TGraphAsymmErrors* g = GetOther(0, aEta, sNN, factor); if (g) { g->SetMarkerStyle(closed); g->SetMarkerColor(kColorCMS); g->SetMarkerSize(size); allCMS->Add(g, "p same"); cms = g; } } }
//________________________________________________________ TObjArray GFOverlay::GetTypeWithNameFromDirs(const TClass *aType, const char *name, const TObjArray &dirs) const { // dirs must contain TDirectory only! // do Get(name) for all dirs and adds result to return value if type fits, otherwise Add(NULL) // result has length of dirs TObjArray result(dirs.GetEntriesFast()); // default length for (Int_t iDir = 0; iDir < dirs.GetEntriesFast(); ++iDir) { TDirectory *aDir = static_cast<TDirectory*>(dirs[iDir]); TObject *obj = (aDir ? aDir->Get(name) : 0); if (obj && !obj->InheritsFrom(aType)) { // delete obj; NO! deletes things found in previous calls... obj = 0; } result.Add(obj); // might be NULL } return result; }
void PublishCanvas(TList *qaList, const char* det, const char* name, TString nadd) { // // draw all nSigma + signal histo // TObjArray arrHistos; TPaveText pt(.1,.1,.9,.9,"NDC"); pt.SetBorderSize(1); pt.SetFillColor(0); pt.SetTextSizePixels(16); pt.AddText(Form("%s PID QA",det)); if (!nadd.IsNull()){ pt.AddText(nadd.Data()); nadd.Prepend("_"); } arrHistos.Add(&pt); TH2 *hSig=Get2DHistogramfromList(qaList,det,Form("hSigP_%s",det)); if (hSig){ hSig->SetOption("colz"); arrHistos.Add(hSig); } for (Int_t i=0;i<AliPID::kSPECIESC;++i){ // for (Int_t i=0;i<AliPID::kSPECIES;++i){ if (i==(Int_t)AliPID::kMuon) continue; TH2 *h=Get2DHistogramfromList(qaList,det,Form(name,AliPID::ParticleName(i))); if (!h) continue; h->SetOption("colz"); AddFit(h); arrHistos.Add(h); } Int_t nPads=arrHistos.GetEntriesFast(); Int_t nCols = (Int_t)TMath::Ceil( TMath::Sqrt(nPads) ); Int_t nRows = (Int_t)TMath::Ceil( (Double_t)nPads/(Double_t)nCols ); fCanvas->Divide(nCols,nRows); for (Int_t i=0; i<nPads;++i) { fCanvas->cd(i+1); SetupPadStyle(); arrHistos.At(i)->Draw(); } fCanvas->Update(); fCanvas->Clear(); }
//______________________________________________________________________________ ROMETree::ROMETree(TTree *tree, ROMEString fileName, ROMEString configInputFileName, ROMEString configOutputFileName, TFile *file, Int_t fileOption, Bool_t read, Bool_t write, Bool_t fill, Bool_t saveConfig, Int_t compressionLevel, Long64_t maxEntries, Int_t compressionAlgorithm) :TNamed() ,fSwitches() ,fSwitchesString("Read = BOOL : 0\n" "Write = BOOL : 0\n" "Fill = BOOL : 0\n" "Save Config = BOOL : 0\n" "Compression Level = INT : 1\n" "Max Entries = INT : 0\n") #if (ROOT_VERSION_CODE >= ROOT_VERSION(5,26,0)) ,fAutoSaveSize(300000000) ,fLastSaveSize(0) ,fAutoFlushSize(-30000000) ,fCacheSize(-1) #else ,fAutoSaveSize(100000000) ,fLastSaveSize(0) ,fAutoFlushSize(-30000000) ,fCacheSize(10000000) #endif ,fBranchActive(0) ,fNBranchActive(0) ,fBranchRead(0) ,fNBranchRead(0) ,fTree(tree) ,fFileName(fileName) ,fConfigInputFileName(configInputFileName) ,fConfigOutputFileName(configOutputFileName) ,fFile(file) ,fFileOption(fileOption) ,fCompressionAlgorithm(compressionAlgorithm) { fSwitches.fRead = read; fSwitches.fWrite = write; fSwitches.fFill = fill; fSwitches.fSaveConfig = saveConfig; fSwitches.fCompressionLevel = compressionLevel; fSwitches.fMaxEntries = static_cast<Int_t>(maxEntries); /* note: use 4byte integer for odb */ if (maxEntries > 0) { fTree->SetCircular(maxEntries); } TObjArray *branches = fTree->GetListOfBranches(); for (Int_t i = 0; i < branches->GetEntriesFast(); i++) { static_cast <TBranch*>(branches->At(i))->SetCompressionLevel(compressionLevel); #if (ROOT_VERSION_CODE >= ROOT_VERSION(5,30,0)) static_cast <TBranch*>(branches->At(i))->SetCompressionAlgorithm(compressionAlgorithm); #endif } }
void getT0RecoParam(Int_t run) { // Read calibration coefficients into the Calibration DB // Arguments: AliCDBManager* man = AliCDBManager::Instance(); man->SetDefaultStorage("raw://"); // man->SetDefaultStorage("local:///home/alla/alice/Jul14/OCDB/"); man->SetRun(run); AliCDBEntry *entry = AliCDBManager::Instance()->Get("T0/Calib/RecoParam"); AliT0RecoParam* recoParam = 0x0; cout<<" entry "<< entry<<endl; if(entry) { // load recoParam according OCDB content (single or array) // if (!(recoParam = dynamic_cast<AliT0RecoParam*>(entry->GetObject()))) { TObjArray* recoParamArray = static_cast<TObjArray*>(entry->GetObject()); cout<<" TObjArray* recoParamArray "<<recoParamArray->GetEntriesFast()<<endl; for(Int_t ie = 0; ie < recoParamArray->GetEntriesFast()-1; ie++) { recoParam = static_cast<AliT0RecoParam*>(recoParamArray->UncheckedAt(ie)); cout<<ie<<endl; cout<<" eq "<<recoParam->GetEq()<<endl; // recoParam->Dump(); cout<<" cfd range "<<recoParam->GetLow(300)<<" amplitude "<<recoParam->GetLow(200)<<" "<<recoParam->GetHigh(200)<<endl; for (int i=0; i<500; i++) if( recoParam->GetLow(i) !=0) cout<<i<<" low "<<recoParam->GetLow(i)<<" "<<endl; for (int i=0; i<500; i++) if( recoParam->GetHigh(i) !=50000) cout<<i<<" high "<<recoParam->GetHigh(i)<<endl; recoParam = 0x0; } } else cout<<" no entry "<<endl; }
//------------------------------ TCut m(TTree *tree, TString var1, TString var2){ Double_t min= tree->GetMinimum("nll_MarkovChain_local_"); TString selMin="nll_MarkovChain_local_ == "; selMin+=min; tree->Draw(">>entrylist",selMin,"entrylist"); TEntryList *entrylist=(TEntryList*) gROOT->FindObject("entrylist"); if(entrylist->GetN()!=1){ std::cout << "Entrylist N=" << entrylist->GetN() << std::endl; return ""; } Long64_t minEntry = entrylist->GetEntry(0); TObjArray *branchArray = tree->GetListOfBranches(); branchArray->GetEntries(); std::vector<TString> minSel_vec; for(int i=0; i < branchArray->GetEntriesFast(); i++){ TBranch *b= (TBranch *) branchArray->At(i); TString name=b->GetName(); Double_t address; b->SetAddress(&address); b->GetEntry(minEntry); name+="==";name+=address; minSel_vec.push_back(name); } TCut cut; for(int i=0; i < branchArray->GetEntriesFast(); i++){ TBranch *b= (TBranch *) branchArray->At(i); TString name=b->GetName(); if(name.Contains("nll")) continue; if(name.Contains(var1)) continue; if(name.Contains(var2)) continue; cut+=minSel_vec[i]; } return cut; }
/// \brief Cache MC production trees, store summary information in formated text files -> root trees /// \param dataType - /// \param fileList void CacheTestMCProductions(TString dataType, const char *fileList=NULL){ AliExternalInfo info; info.fLoadMetadata=kFALSE; TObjArray* periodList = NULL; TArrayI nRuns; if (fileList!=NULL) { periodList=(gSystem->GetFromPipe(TString::Format("cat %s", fileList).Data())).Tokenize("\n"); nRuns.Set(periodList->GetEntries()); }else{ TTree * tree = info.GetTree("MonALISA.ProductionMC","",""); Int_t nProd=tree->GetEntries(); periodList = new TObjArray(nProd); nRuns.Set(nProd); TLeaf *leaf = tree->GetLeaf("Tag"); TLeaf *leafRuns = tree->GetLeaf("Number_of_runs"); for (Int_t iProd=0; iProd<nProd; iProd++){ tree->GetEntry(iProd); TString prodName=((char*)leaf->GetValuePointer()); if (prodName.Contains("LHC")==0) continue; periodList->AddAt(new TObjString(((char*)leaf->GetValuePointer())),iProd); nRuns[iProd]=leafRuns->GetValue(); } delete tree; } for (Int_t iPeriod=0; iPeriod<periodList->GetEntriesFast(); iPeriod++){ TObjString * pName= (TObjString*)periodList->At(iPeriod); if (pName==NULL) continue; TTree* tree = info.GetTree(dataType.Data(),periodList->At(iPeriod)->GetName(),"passMC"); if (tree){ Int_t entries=tree->Draw("run","1","goff"); TString sInfo=periodList->At(iPeriod)->GetName(); sInfo+="\t"; sInfo+=dataType; sInfo+="\t"; sInfo+=TString::Format("%d\t",entries); sInfo+=TString::Format("%d\t",nRuns[iPeriod]); for (Int_t j=0; j<entries; j++) { sInfo+=TString::Format("%2.0f,",tree->GetV1()[j]); ::Info("CacheTestMCProductionsRun:","%s\t%s\t%d\t%d\t%d\t%2.0f",periodList->At(iPeriod)->GetName(),dataType.Data(),entries,nRuns[iPeriod],j, tree->GetV1()[j]); } sInfo+="0"; ::Info("CacheTestMCProductionsPeriod:","%s\n",sInfo.Data()); delete tree; }else{ ::Error("CacheTestMCProductionsPeriod:","%s\t%s\t-1\t%d\t0",periodList->At(iPeriod)->GetName(), dataType.Data(),nRuns[iPeriod]); } } }
//________________________________________________________ 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; }
void selector::Begin(TTree *) { // Can pass a string option which is 4th argument of runselector.C // You can retrieve the option in any function in this file. TString option = GetOption(); printf("Begin: The option is %s\n",option.Data()); // This code parses the options and finds options separated by white space TObjArray *Strings = option.Tokenize(" "); if(Strings->GetEntriesFast()) { TIter iString(Strings); TObjString* os=0; Int_t j=0; while ((os=(TObjString*)iString())) { printf("token #%d ='%s'\n",j++, os->GetString().Data()); } } delete Strings; // Print help message to users if( option == "-h" ) { printf("selector_null: sample selector function\n"); printf(" Edward Diehl 3/29/09\n"); exit(0); //Abort job } //Book histograms // histlist = new TList(); raw_adc = new TH1F("raw_adc","ADC",100,0.,500.); raw_tdc = new TH1F("raw_tdc","TDC",100,0.,3000.); raw_adc_ntube = new TH2F("raw_adc_ntube","ADC",100,0.,500.,1,0.,MAXCHAMBERS); rawMdt_gposX_gposY = new TH2F("rawMdt_gposX_gposY","rawMdt XvY",100,-15,15,100,-15,15); rawMdt_gposY_gposZ = new TH2F("rawMdt_gposY_gposZ","rawMdt YvZ",100,-15,15,100,-15,15); //Loop over chambers /* for(int i=0;1<MAXCHAMBERS;i++){ rawadc_chamber[i] = new TH1F(Form("rawADC_%s",chlist[i].calname),Form("%s raw ADC",chlist[i].calname),100,0,500); //chlist is array in chamberlist that contains detector names e.g BEE_1_2 // } //loop over multilayer and chambers for(int j=0; j<MAXCHAMBERS; j++ ) { //Chambers for( int i=0; i<2; i++ ) { //ML int ml = i + 1 ; raw_adc[j][i] = raw_tdc[j][i] = */ }