TH1* hminv = fHC->Histo("MinvUSPt:py");
- if (!hminv || hminv->GetEntries()==0 ) return;
+ if (!hminv || hminv->GetEntries()<100 ) return;
fMinv = static_cast<TH1*>(hminv->Clone(Form("minv%d",n)));
fMinv->Rebin(fRebin);
// strict cuts on pairs
}
- Print();
+// Print();
}
//_____________________________________________________________________________
//_____________________________________________________________________________
void AliAnalysisMuMu::Result::Print(Option_t* /*opt*/) const
{
- std::cout << Form("%9s %20s NTRIGGER %10d",
+ std::cout << Form("%20s - %s %s %s - NRUNS %d - NTRIGGER %10d",
GetName(),
- fTriggerName.Data(),
- fNofTriggers) << std::endl;
+ EventSelection(),
+ PairSelection(),
+ CentralitySelection(),
+ NofRuns(),
+ NofTriggers()) << std::endl;
if (NofJpsi())
{
//_____________________________________________________________________________
-TString FindTrigger(const AliHistogramCollection& hc,
+TString FindTrigger(const AliHistogramCollection& hc,
const char* base,
const char* selection,
const char* paircut,
TString AliAnalysisMuMu::fgOCDBPath("raw://");
+TString AliAnalysisMuMu::fgDefaultDimuonTriggers("CMUL7-S-NOPF-ALLNOTRD,CMUL7-S-NOPF-MUON,CMUL8-S-NOPF-MUON,CMUL7-B-NOPF-ALLNOTRD,CMUL7-B-NOPF-MUON,CMUU7-B-NOPF-ALLNOTRD,CMUU7-B-NOPF-MUON,CPBI1MUL-B-NOPF-MUON");
+
+TString AliAnalysisMuMu::fgDefaultMuonTriggers("CMSL7-S-NOPF-MUON,CMSL7-S-NOPF-ALLNOTRD,CMSL8-S-NOPF-MUON,CMSL8-S-NOPF-ALLNOTRD,CMSL7-B-NOPF-MUON,CMUS1-B-NOPF-MUON,CMUS7-B-NOPF-MUON");
+
+TString AliAnalysisMuMu::fgDefaultMinbiasTriggers("CINT7-B-NOPF-ALLNOTRD,CINT7-S-NOPF-ALLNOTRD,CINT8-B-NOPF-ALLNOTRD,CINT8-S-NOPF-ALLNOTRD,CINT1-B-NOPF-ALLNOTRD,CPBI2_B1-B-NOPF-ALLNOTRD");
+
+TString AliAnalysisMuMu::fgDefaultEventSelectionList("ALL");
+
+TString AliAnalysisMuMu::fgDefaultPairSelectionList("pMATCHLOWRABSDCABOTH");
+
//_____________________________________________________________________________
AliAnalysisMuMu::AliAnalysisMuMu(const char* filename) : TObject(),
fFilename(filename),
fHistogramCollection(0x0),
fCounterCollection(0x0),
-fDimuonTriggers("CMUL7-S-NOPF-ALLNOTRD CMUL7-S-NOPF-MUON CMUL8-S-NOPF-MUON CMUL7-B-NOPF-ALLNOTRD CMUL7-B-NOPF-MUON CMUU7-B-NOPF-ALLNOTRD CMUU7-B-NOPF-MUON CPBI1MUL-B-NOPF-MUON"),
-fMuonTriggers("CMSL7-S-NOPF-MUON CMSL8-S-NOPF-MUON CMSL7-B-NOPF-MUON CMUS1-B-NOPF-MUON CMUS7-B-NOPF-MUON"),
-fMinbiasTriggers("CINT7-B-NOPF-ALLNOTRD CINT7-S-NOPF-ALLNOTRD CINT8-B-NOPF-ALLNOTRD CINT8-S-NOPF-ALLNOTRD CINT1-B-NOPF-ALLNOTRD CPBI2_B1-B-NOPF-ALLNOTRD")
+fDimuonTriggers(fgDefaultDimuonTriggers),
+fMuonTriggers(fgDefaultMuonTriggers),
+fMinbiasTriggers(fgDefaultMinbiasTriggers),
+fEventSelectionList(fgDefaultEventSelectionList),
+fPairSelectionList(fgDefaultPairSelectionList)
{
// ctor
}
//_____________________________________________________________________________
-void AliAnalysisMuMu::BasicCounts(Bool_t detailTriggers)
+void AliAnalysisMuMu::BasicCounts(Bool_t detailTriggers,
+ ULong64_t* totalNmb,
+ ULong64_t* totalNmsl,
+ ULong64_t* totalNmul)
{
// Report of some basic numbers, like number of MB and MUON triggers,
// both before and after physics selection, and comparison with
TObjArray* events = fCounterCollection->GetKeyWords("event").Tokenize(",");
+ Bool_t doPS = (events->FindObject("PSALL") != 0x0);
+
TObjString* srun;
TObjString* strigger;
- ULong64_t totalNmb(0);
- ULong64_t totalNmsl(0);
- ULong64_t totalNmul(0);
+ ULong64_t localNmb(0);
+ ULong64_t localNmsl(0);
+ ULong64_t localNmul(0);
+
+ if ( totalNmb) *totalNmb = 0;
+ if ( totalNmsl) *totalNmsl = 0;
+ if ( totalNmul ) *totalNmul = 0;
while ( ( srun = static_cast<TObjString*>(nextRun()) ) )
{
nextTrigger.Reset();
+ Int_t nofPS(0);
+
while ( ( strigger = static_cast<TObjString*>(nextTrigger()) ) )
{
+
+ if ( !fgDefaultMinbiasTriggers.Contains(strigger->String().Data()) &&
+ !fgDefaultMuonTriggers.Contains(strigger->String().Data()) &&
+ !fgDefaultDimuonTriggers.Contains(strigger->String().Data()) ) continue;
+
ULong64_t n = fCounterCollection->GetSum(Form("trigger:%s/event:%s/run:%d",
strigger->String().Data(),"ALL",srun->String().Atoi()));
- details += Form("\n%50s %10lld",strigger->String().Data(),n);
+ details += TString::Format("\n%50s %10lld",strigger->String().Data(),n);
- ULong64_t nps(0);
-
- if ( events->FindObject("PSALL") )
+ ULong64_t nps = fCounterCollection->GetSum(Form("trigger:%s/event:%s/run:%d",
+ strigger->String().Data(),"PSALL",srun->String().Atoi()));
+
+ if ( doPS )
{
- nps = fCounterCollection->GetSum(Form("trigger:%s/event:%s/run:%d",
- strigger->String().Data(),"PSALL",srun->String().Atoi()));
- details += Form(" PS %5.1f %%",nps*100.0/n);
+ details += TString::Format(" PS %5.1f %%",nps*100.0/n);
}
+ if (nps)
+ {
+ ++nofPS;
+ }
+
if ( fMinbiasTriggers.Contains(strigger->String()) )
{
nmb += n;
- totalNmb += n;
+ if ( totalNmb) (*totalNmb) += n;
+ localNmb += n;
}
else if ( fMuonTriggers.Contains(strigger->String()) )
{
nmsl += n;
- totalNmsl += n;
+ if ( totalNmsl) (*totalNmsl) += n;
+ localNmsl += n;
}
else if ( fDimuonTriggers.Contains(strigger->String()) )
{
nmul += n;
- totalNmul += n;
+ if ( totalNmul ) (*totalNmul) += n;
+ localNmul += n;
}
}
- std::cout << Form("MB %10lld MSL %10lld MUL %10lld ",
- nmb,nmsl,nmul);
+ std::cout << Form("MB %10lld MSL %10lld MUL %10lld %s",
+ nmb,nmsl,nmul,(nofPS == 0 ? "(NO PS AVAIL)": ""));
if ( detailTriggers )
{
std::cout << std::endl;
}
- std::cout << std::endl << Form("%13s MB %10lld MSL %10lld MUL %10lld ","TOTAL",
- totalNmb,totalNmsl,totalNmul) << std::endl;
+ if ( !totalNmul && !totalNmsl && !totalNmb )
+ {
+ std::cout << std::endl << Form("%13s MB %10lld MSL %10lld MUL %10lld ","TOTAL",
+ localNmb,localNmsl,localNmul) << std::endl;
+ }
- delete runs;
+ delete runs;
delete triggers;
delete events;
}
+//_____________________________________________________________________________
+void AliAnalysisMuMu::BasicCountsEvolution(const char* filelist, Bool_t detailTriggers)
+{
+ // Report of some basic numbers, like number of MB and MUON triggers,
+ // both before and after physics selection, and comparison with
+ // the total number of such triggers (taken from the OCDB scalers)
+ // if requested.
+ //
+ // if detailTriggers is kTRUE, each kind of (MB,MUL,MSL) is counted separately
+ //
+ // To change the list of (single muon, dimuon, MB) triggers, use
+ // the SetDefault*TriggerList methods prior to call this one
+ //
+
+ TObjArray* files = ReadFileList(filelist);
+
+ if (!files || files->IsEmpty() ) return;
+
+ TIter next(files);
+ TObjString* str;
+
+ ULong64_t totalNmb(0);
+ ULong64_t totalNmsl(0);
+ ULong64_t totalNmul(0);
+
+ while ( ( str = static_cast<TObjString*>(next()) ) )
+ {
+ AliAnalysisMuMu m(str->String().Data());
+
+ ULong64_t nmb(0);
+ ULong64_t nmsl(0);
+ ULong64_t nmul(0);
+
+ m.BasicCounts(detailTriggers,&nmb,&nmsl,&nmul);
+
+ totalNmb += nmb;
+ totalNmsl += nmsl;
+ totalNmul += nmul;
+ }
+
+ std::cout << std::endl << Form("%13s MB %10lld MSL %10lld MUL %10lld ","TOTAL",
+ totalNmb,totalNmsl,totalNmul) << std::endl;
+
+}
+
//_____________________________________________________________________________
TObjArray* AliAnalysisMuMu::CompareJpsiPerCMUUWithBackground(const char* jpsiresults,
const char* backgroundresults)
std::map<std::string, std::vector<float> > yplus,erryplus;
std::map<std::string, std::vector<float> > yminus,erryminus;
- TObjArray* triggers = TString(triggerList).Tokenize(" ");
+ TObjArray* triggers = TString(triggerList).Tokenize(",");
TObjArray* a = new TObjArray;
a->SetOwner(kTRUE);
return a;
}
+//_____________________________________________________________________________
+TMap*
+AliAnalysisMuMu::ComputeJpsiEvolution(const char* filelist, const char* triggerList,
+ const char* outputFile, const char* outputMode,
+ Bool_t simulation)
+{
+ /// Compute some jpsi information for a list of files / trigger combinations
+
+ TObjArray* files = ReadFileList(filelist);
+
+ if (!files || files->IsEmpty() ) return 0x0;
+
+ TMap results; // one TObjString->TObjArray per file
+ results.SetOwnerKeyValue(kTRUE,kTRUE);
+
+ TIter nextFile(files);
+ TObjString* str;
+ UInt_t fitType(0);
+
+ while ( ( str = static_cast<TObjString*>(nextFile()) ) )
+ {
+ std::cout << str->String().Data() << std::endl;
+
+ AliAnalysisMuMu m(str->String().Data());
+
+ m.SetDimuonTriggerList(triggerList);
+ m.SetEventSelectionList("ALL");
+
+ TObjArray* array = m.Jpsi(simulation); // the array will contain results for all triggers in fDimuonTriggers variable
+
+ if (!array)
+ {
+ AliWarningClass(Form("Got no jpsi for %s",str->String().Data()));
+ }
+ else
+ {
+ Result* r = static_cast<Result*>(array->First());
+ if (!r) continue;
+ fitType = r->FitType();
+ }
+
+ results.Add(new TObjString(str->String()), array);
+ }
+
+ if (!results.GetSize()) return 0x0;
+
+ // compute the total over all files
+
+ TMap* total = new TMap;
+ total->SetOwnerKeyValue(kTRUE,kTRUE);
+
+ nextFile.Reset();
+ TObjArray* triggers = TString(triggerList).Tokenize(",");
+
+ TIter nextTrigger(triggers);
+ TObjString* trigger(0x0);
+
+ while ( ( trigger = static_cast<TObjString*>(nextTrigger())))
+ {
+ nextFile.Reset();
+
+ Int_t nruns(0);
+ Int_t n(0);
+ TList l;
+ Result* ref(0x0);
+ AliHistogramCollection* hc(0x0);
+
+ while ( ( str = static_cast<TObjString*>(nextFile()) ) )
+ {
+ TObjArray* a = static_cast<TObjArray*>(results.GetValue(str->String().Data()));
+
+ Result* r(0x0);
+
+ if (a)
+ {
+ r = static_cast<Result*>(a->FindObject(trigger->String().Data()));
+
+ if (r)
+ {
+ if (!ref) ref = r;
+
+ if ( !hc )
+ {
+ AliHistogramCollection* htmp = r->HC();
+ if (!htmp)
+ {
+ continue;
+ }
+ hc = static_cast<AliHistogramCollection*>(htmp->Clone(Form("hc%d",0)));
+ }
+ else
+ {
+ l.Add(r->HC());
+ }
+
+ n += r->NofTriggers();
+ ++nruns;
+ }
+ }
+ }
+
+ hc->Merge(&l);
+
+ if (!ref) continue;
+
+ Result* sum = new Result(ref->TriggerClass(),ref->EventSelection(),
+ ref->PairSelection(),ref->CentralitySelection(),
+ n,hc,1,fitType);
+
+ sum->SetNofRuns(nruns);
+
+ total->Add(new TObjString(trigger->String().Data()),sum);
+
+ }
+
+ StdoutToAliInfoClass(total->Print(););
+
+ TFile* fout = new TFile(outputFile,outputMode);
+
+ results.Write("rbr",TObject::kSingleKey|TObject::kOverwrite);
+
+ total->Write("total",TObject::kSingleKey|TObject::kOverwrite);
+
+ delete fout;
+
+ AliInfoClass(Form("%d files analyzed",files->GetEntries()));
+
+ return total;
+}
+
//_____________________________________________________________________________
Bool_t AliAnalysisMuMu::DecodeFileName(const char* filename,
TString& period,
return kTRUE;
}
+//______________________________________________________________________________
+void AliAnalysisMuMu::DrawFill(Int_t run1, Int_t run2, double ymin, double ymax, const char* label)
+{
+ AliDebugClass(1,Form("RUN1 %09d RUN2 %09d YMIN %e YMAX %e %s",
+ run1,run2,ymin,ymax,label));
+ TBox* b = new TBox(run1*1.0,ymin,run2*1.0,ymax);
+ b->SetFillColor(5);
+ b->Draw();
+ TText* text = new TText((run1+run2)/2.0,ymax*0.85,label);
+ text->SetTextSize(0.025);
+ text->SetTextFont(42);
+ text->SetTextAlign(23);
+ text->SetTextAngle(45);
+ text->Draw();
+}
+
//_____________________________________________________________________________
TString
AliAnalysisMuMu::ExpandPathName(const char* file)
AliAnalysisTriggerScalers ts(runNumber,fgOCDBPath.Data());
- TObjArray* triggers = TString(triggerList).Tokenize(" ");
+ TObjArray* triggers = TString(triggerList).Tokenize(",");
TObjString* trigger;
TIter next(triggers);
ULong64_t n(0);
TObjArray*
AliAnalysisMuMu::Jpsi(Bool_t simulation)
{
+ // Fit the J/psi (and psiprime) peaks for the triggers in fDimuonTriggers list
+
TObjArray* a = new TObjArray;
a->SetOwner(kTRUE);
{
const char* selection = "ALL";
- Add(a,GetResult(*fHistogramCollection,*fCounterCollection,"ANY",selection,"sALL","pMATCHLOWRABSBOTH","PP",Result::kJpsi));
+ Add(a,GetResult(*fHistogramCollection,*fCounterCollection,"ANY",selection,"pMATCHLOWRABSBOTH","PP",Result::kJpsi));
}
else
{
- const char* eventSelection[] = { "ALL", "PSALL" };//, "PSTVX", "PSNOTVX", "NOTVX" };
- const char* pairSelection[] = { "pMATCHLOWRABSDCABOTH" , "pMATCHLOWRABSDCA" };
+ TObjArray* triggerArray = fDimuonTriggers.Tokenize(",");
+ TObjArray* eventTypeArray = fEventSelectionList.Tokenize(",");
+ TObjArray* pairCutArray = fPairSelectionList.Tokenize(",");
- for ( int i = 0; i < 1; ++i )
+ TIter nextTrigger(triggerArray);
+ TIter nextEventType(eventTypeArray);
+ TIter nextPairCut(pairCutArray);
+
+ TObjString* trigger;
+ TObjString* eventType;
+ TObjString* pairCut;
+
+ while ( ( trigger = static_cast<TObjString*>(nextTrigger())) )
{
- for ( int j = 0; j < 1; ++j )
+ AliDebug(1,Form("TRIGGER %s",trigger->String().Data()));
+
+ nextEventType.Reset();
+
+ while ( ( eventType = static_cast<TObjString*>(nextEventType())) )
{
+ AliDebug(1,Form("EVENTTYPE %s",eventType->String().Data()));
- Add(a,GetResult(*fHistogramCollection,*fCounterCollection,"CMUL8-S-NOPF-MUON",eventSelection[i],"sALL",pairSelection[j],"PP",Result::kJpsi | Result::kJpsiPrime,2));
-
- Add(a,GetResult(*fHistogramCollection,*fCounterCollection,"CMUL7-S-NOPF-ALLNOTRD",eventSelection[i],"sALL",pairSelection[j],"PP",Result::kJpsi | Result::kJpsiPrime,2));
-
- Add(a,GetResult(*fHistogramCollection,*fCounterCollection,"CMUL7-S-NOPF-MUON",eventSelection[i],"sALL",pairSelection[j],"PP",Result::kJpsi | Result::kJpsiPrime,2));
-
- Add(a,GetResult(*fHistogramCollection,*fCounterCollection,"C0MUL-SC-NOPF-MUON",eventSelection[i],"sALL",pairSelection[j],"PP",Result::kJpsi | Result::kJpsiPrime,2));
-
+ nextPairCut.Reset();
+ while ( ( pairCut = static_cast<TObjString*>(nextPairCut())) )
+ {
+ AliDebug(1,Form("PAIRCUT %s",pairCut->String().Data()));
+ Add(a,GetResult(*fHistogramCollection,*fCounterCollection,
+ trigger->String().Data(),
+ eventType->String().Data(),
+ pairCut->String().Data(),
+ "PP",
+ Result::kJpsi | Result::kJpsiPrime,2));
+ }
}
}
+ delete triggerArray;
+ delete eventTypeArray;
+ delete pairCutArray;
}
if ( a->GetLast() < 0 )
}
//_____________________________________________________________________________
-TObjArray*
-AliAnalysisMuMu::JpsiEvolution(const char* filelist, const char* outputFile, Bool_t simulation)
-{
- TObjArray* files = ReadFileList(filelist);
-
- if (!files || files->IsEmpty() ) return 0x0;
-
- std::vector<float> nof, errnof, mean, errmean, sigma, errsigma, x,errx, ntriggers, errntriggers;
- std::vector<float> nofupsilon, errnofupsilon, meanupsilon, errmeanupsilon, sigmaupsilon, errsigmaupsilon;
+void
+AliAnalysisMuMu::PlotJpsiEvolution(const char* resultFile, const char* triggerList, Bool_t fillBoundaries,
+ const char* efficiencyFile)
+{
+ if ( efficiencyFile && strlen(efficiencyFile) > 0 )
+ {
+ std::ifstream in(gSystem->ExpandPathName(efficiencyFile));
+ if (!in.bad())
+ {
+ char line[1024];
+ int run;
+ float eff, error;
+ while ( in.getline(line,1023,'\n') )
+ {
+ sscanf(line,"%d %f ± %f",&run,&eff,&error);
+ AliInfoClass(Form("%09d %8.6f ± %8.6f",run,eff,error));
+ }
+ }
+
+ return;
+ }
- std::map<std::string,TObjArray*> results;
+ TFile* f = TFile::Open(gSystem->ExpandPathName(resultFile));
- int dim(0);
+ std::map<int, std::pair<int,int> > fills;
- TIter next(files);
+ TMap* m = static_cast<TMap*>(f->Get("rbr"));
+
+ TIter next(m);
TObjString* str;
- UInt_t fitType(0);
- while ( ( str = static_cast<TObjString*>(next()) ) )
+ TObjArray files;
+ files.SetOwner(kTRUE);
+
+ while ( ( str = static_cast<TObjString*>(next())) )
{
- std::cout << str->String().Data() << std::endl;
-
- AliAnalysisMuMu m(str->String().Data());
-
- TObjArray* array = m.Jpsi(simulation);
-
- if (!array)
- {
- std::cout << "Got no jpsi for " << str->String().Data() << std::endl;
- }
- else
- {
- Result* r = static_cast<Result*>(array->First());
- if (!r) continue;
- fitType = r->FitType();
- }
-
- if (array) dim = TMath::Max(dim,array->GetLast()+1);
- results.insert(std::make_pair<std::string,TObjArray*>(str->String().Data(),array));
-
-// gROOT->CloseFiles();
+ files.Add(new TObjString(str->String()));
}
- if (results.empty()) return 0x0;
+ files.Sort();
- std::map<std::string,TObjArray*>::const_iterator it;
- TObjArray* total = new TObjArray;
- total->SetOwner(kTRUE);
+ std::map<std::string, std::vector<float> > x_jpsirate;
+ std::map<std::string, std::vector<float> > y_jpsirate;
+ std::map<std::string, std::vector<float> > xerr_jpsirate;
+ std::map<std::string, std::vector<float> > yerr_jpsirate;
- int seq(0);
+ TIter nextTrigger(TString(triggerList).Tokenize(","));
+ TObjString* trigger(0x0);
- for ( int i = 0; i < dim; ++i )
+ int runMin(100000000);
+ int runMax(0);
+
+ TIter nextFile(&files);
+
+ while ( ( trigger = static_cast<TObjString*>(nextTrigger())))
{
- Int_t n(0);
-
- AliHistogramCollection* hc(0x0);
+ TString triggerClass(trigger->String());
- TList l;
+ nextFile.Reset();
- TString name;
- next.Reset();
-
- while ( ( str = static_cast<TObjString*>(next()) ) )
+ while ( ( str = static_cast<TObjString*>(nextFile())) )
{
- TObjArray* a = results[str->String().Data()];
-
- Result* r(0x0);
-
- if (a)
+ TObjArray* a = static_cast<TObjArray*>(m->GetValue(str->String().Data()));
+ if (!a) continue;
+ Result* r = static_cast<Result*>(a->FindObject(triggerClass.Data()));
+ if (!r) continue;
+
+ TString period;
+ int aodtrain,esdpass,runnumber;
+
+ if ( DecodeFileName(str->String().Data(),period,esdpass,aodtrain,runnumber) )
{
- r = static_cast<Result*>(a->At(i));
+ runMin = TMath::Min(runMin,runnumber);
+ runMax = TMath::Max(runMax,runnumber);
- if (r)
+ x_jpsirate[triggerClass.Data()].push_back(runnumber);
+ xerr_jpsirate[triggerClass.Data()].push_back(0.5);
+
+ if ( fillBoundaries )
{
- if ( !hc )
+ AliAnalysisTriggerScalers ts(runnumber,fgOCDBPath.Data());
+ int fill = ts.GetFillNumberFromRunNumber(runnumber);
+
+ if (fills.count(fill))
{
- AliHistogramCollection* htmp = r->HC();
- if (!htmp)
- {
- continue;
- }
- hc = static_cast<AliHistogramCollection*>(htmp->Clone(Form("hc%d",i)));
- name = r->TriggerClass();
+ std::pair<int,int>& p = fills[fill];
+ p.first = TMath::Min(runnumber,p.first);
+ p.second = TMath::Max(runnumber,p.second);
}
else
{
- l.Add(r->HC());
+ fills[fill] = make_pair<int,int>(runnumber,runnumber);
}
}
- }
-
- if (i==0)
- {
- TString period;
- int aodtrain,esdpass,runnumber;
- if ( DecodeFileName(str->String().Data(),period,esdpass,aodtrain,runnumber) )
- {
- x.push_back(runnumber);
- }
- else
- {
- x.push_back(seq++);
- }
- errx.push_back(0.5);
+ Double_t y(0.0);
+ Double_t yerr(0.0);
- if ( !r ||
- !TMath::Finite(r->SigmaJpsi()) )
- {
- nof.push_back(0);
- errnof.push_back(0);
- mean.push_back(0);
- sigma.push_back(0);
- errmean.push_back(0);
- errsigma.push_back(0);
- ntriggers.push_back(0);
- errntriggers.push_back(0);
-
- nofupsilon.push_back(0);
- errnofupsilon.push_back(0);
- meanupsilon.push_back(0);
- errmeanupsilon.push_back(0);
- sigmaupsilon.push_back(0);
- errsigmaupsilon.push_back(0);
- }
- else
+ if ( TMath::Finite(r->SigmaJpsi()) && r->NofTriggers() > 10 )
{
-// r->Print();
+ y = 100*r->NofJpsi()/r->NofTriggers();
- nof.push_back(r->NofJpsi()/r->NofTriggers());
- errnof.push_back(r->ErrorOnNofJpsi()/r->NofTriggers());
- mean.push_back(r->MeanJpsi());
- sigma.push_back(r->SigmaJpsi());
- errmean.push_back(r->ErrorOnMeanJpsi());
- errsigma.push_back(r->ErrorOnSigmaJpsi());
- ntriggers.push_back(r->NofTriggers());
- errntriggers.push_back(TMath::Sqrt(r->NofTriggers()));
-
- nofupsilon.push_back(r->NofUpsilon()/r->NofTriggers());
- errnofupsilon.push_back(r->ErrorOnNofUpsilon()/r->NofTriggers());
- meanupsilon.push_back(r->MeanUpsilon());
- sigmaupsilon.push_back(r->SigmaUpsilon());
- errmeanupsilon.push_back(r->ErrorOnMeanUpsilon());
- errsigmaupsilon.push_back(r->ErrorOnSigmaUpsilon());
-
+ if ( r->NofJpsi() > 0 )
+ {
+ yerr = y * TMath::Sqrt( (r->ErrorOnNofJpsi()*r->ErrorOnNofJpsi())/(r->NofJpsi()*r->NofJpsi()) + 1.0/r->NofTriggers());
+ }
}
+
+ y_jpsirate[triggerClass.Data()].push_back(y);
+ yerr_jpsirate[triggerClass.Data()].push_back(yerr);
}
-
- if ( r ) n += r->NofTriggers();
}
-
- hc->Merge(&l);
-
- Result* sum = new Result(Form("%s %d runs",name.Data(),(int)results.size()),n,hc,1,fitType);
-
- sum->Print();
- // std::cout << Form("sum %p h=%p",sum,sum->Minv()) << std::endl;
-
- total->Add(sum);
-
}
-
-
- new TCanvas;
-
- TGraphErrors* grate = new TGraphErrors(nof.size(),&x[0],&nof[0],&errx[0],&errnof[0]);
-
- grate->GetXaxis()->SetNoExponent();
- grate->Draw("ALP");
-// grate->SetTitle("J/psi per CMUU");
- grate->SetTitle("J/psi acc*eff");
- grate->SetName("jpsiacceff");
-
- new TCanvas;
-
- TGraphErrors* gsigma = new TGraphErrors(nof.size(),&x[0],&sigma[0],&errx[0],&errsigma[0]);
-
- gsigma->GetXaxis()->SetNoExponent();
- gsigma->Draw("ALP");
- gsigma->SetTitle("J/psi sigma");
- gsigma->SetName("jpsisigma");
-
- new TCanvas;
-
- TGraphErrors* gmean = new TGraphErrors(nof.size(),&x[0],&mean[0],&errx[0],&errmean[0]);
-
- gmean->GetXaxis()->SetNoExponent();
- gmean->Draw("ALP");
- gmean->SetTitle("J/psi mean");
- gmean->SetName("jpsimean");
- new TCanvas;
-
- TGraphErrors* gntriggers = new TGraphErrors(nof.size(),&x[0],&ntriggers[0],&errx[0],&errntriggers[0]);
-
- gntriggers->GetXaxis()->SetNoExponent();
- gntriggers->Draw("ALP");
- gntriggers->SetTitle("number of triggers");
- gntriggers->SetName("ntriggers");
-
- new TCanvas;
-
- TGraphErrors* grateupsilon = new TGraphErrors(nofupsilon.size(),&x[0],&nofupsilon[0],&errx[0],&errnofupsilon[0]);
-
- grateupsilon->GetXaxis()->SetNoExponent();
- grateupsilon->Draw("ALP");
- // grate->SetTitle("J/psi per CMUU");
- grateupsilon->SetTitle("Upsilon acc*eff");
- grateupsilon->SetName("upsilonacceff");
+ delete f;
- new TCanvas;
+ TCanvas* c = new TCanvas("cJpsiRateEvolution","cJpsiRateEvolution");
- TGraphErrors* gsigmaupsilon = new TGraphErrors(nofupsilon.size(),&x[0],&sigmaupsilon[0],&errx[0],&errsigmaupsilon[0]);
+ c->Draw();
- gsigmaupsilon->GetXaxis()->SetNoExponent();
- gsigmaupsilon->Draw("ALP");
- gsigmaupsilon->SetTitle("upsilon sigma");
- gsigmaupsilon->SetName("upsilonsigma");
+ Double_t ymin(0);
+ Double_t ymax(2);
- new TCanvas;
+ TH2* h = new TH2F("h","h;RunNumber;J/#psi per CMUL (%)",100,runMin,runMax,100,ymin,ymax);
- TGraphErrors* gmeanupsilon = new TGraphErrors(nofupsilon.size(),&x[0],&meanupsilon[0],&errx[0],&errmeanupsilon[0]);
+ gStyle->SetOptTitle(0);
+ gStyle->SetOptStat(0);
- gmeanupsilon->GetXaxis()->SetNoExponent();
- gmeanupsilon->Draw("ALP");
- gmeanupsilon->SetTitle("upsilon mean");
- gmeanupsilon->SetName("upsilonmean");
+ h->GetXaxis()->SetNoExponent();
- TFile fout(outputFile,"RECREATE");
+ h->Draw();
+
+ if (fillBoundaries)
+ {
+ std::map<int, std::pair<int,int> >::const_iterator it;
+
+ for ( it = fills.begin(); it != fills.end(); ++it )
+ {
+ const std::pair<int,int>& p = it->second;
+ TString fillnumber;
+ fillnumber.Form("%d",it->first);
+ DrawFill(p.first,p.second,ymin,ymax,fillnumber.Data());
+ }
+ }
+
+ h->Draw("sameaxis");
- grate->Write();
- gsigma->Write();
- gmean->Write();
- gntriggers->Write();
- grateupsilon->Write();
- gmeanupsilon->Write();
- gsigmaupsilon->Write();
+ //c->RedrawAxis("g");
+
+ nextTrigger.Reset();
- total->Write("results",TObject::kSingleKey|TObject::kOverwrite);
+ int i(0);
+ int color[] = { 1,2,4,5,6 };
+ int marker[] = { 20,23,25,21,22 };
- fout.Close();
+ while ( ( trigger = static_cast<TObjString*>(nextTrigger())))
+ {
+ std::vector<float>& x = x_jpsirate[trigger->String().Data()];
+ std::vector<float>& y = y_jpsirate[trigger->String().Data()];
+ std::vector<float>& xerr = xerr_jpsirate[trigger->String().Data()];
+ std::vector<float>& yerr = yerr_jpsirate[trigger->String().Data()];
+
+ TGraphErrors* g = new TGraphErrors(x.size(),&x[0],&y[0],&xerr[0],&yerr[0]);
+
+ g->SetLineColor(color[i]);
+ g->SetMarkerColor(color[i]);
+ g->SetMarkerStyle(marker[i]);
+ g->GetXaxis()->SetNoExponent();
+ g->Draw("LP");
+// g->Print();
+
+ Double_t m2 = g->GetMean(2);
+
+ TLine* line = new TLine(runMin,m2,runMax,m2);
+ line->SetLineColor(color[i]);
+ line->Draw();
+
+ AliInfoClass(Form("TRIGGER %s MEAN %7.2f",trigger->String().Data(),m2));
+ ++i;
+ }
- std::cout << files->GetEntries() << " files analysed" << std::endl;
- return total;
}
//_____________________________________________________________________________
-AliAnalysisMuMu::Result*
+AliAnalysisMuMu::Result*
AliAnalysisMuMu::GetResult(const AliHistogramCollection& hc,
- AliCounterCollection& cc,
- const char* base,
- const char* selection,
- const char* trackcut,
- const char* paircut,
- const char* centrality,
- UInt_t fitType,
- Int_t nrebin)
+ AliCounterCollection& cc,
+ const char* base,
+ const char* selection,
+ const char* paircut,
+ const char* centrality,
+ UInt_t fitType,
+ Int_t nrebin)
{
Result* r(0x0);
-
+
TString trigger = FindTrigger(hc,base,selection,paircut,centrality);
- if ( trigger == "" ) return 0;
+ if ( trigger == "" )
+ {
+ return 0;
+ }
Int_t ntrigger = (Int_t)cc.GetSum(Form("trigger:%s/event:%s",trigger.Data(),selection));
// new TCanvas;
- r = new Result(Form("%s - %s - %s - %s - %s",trigger.Data(),selection,trackcut,paircut,centrality),
+ r = new Result(trigger.Data(),
+ selection,
+ paircut,
+ centrality,
ntrigger,
- hc.Project(selection,trigger.Data(),centrality,paircut),
+ hc.Project(selection,trigger,centrality,paircut),
nrebin,
fitType);
l->SetTextColor(AliAnalysisMuMu::kBlue);
l->SetLineColor(AliAnalysisMuMu::kBlue);
- TObjArray* triggers = TString(triggerList).Tokenize(" ");
+ TObjArray* triggers = TString(triggerList).Tokenize(",");
gStyle->SetOptTitle(0);
}
//_____________________________________________________________________________
-void AliAnalysisMuMu::TriggerCountCoverage(const char* triggerList)
+void AliAnalysisMuMu::TriggerCountCoverage(const char* triggerList, Bool_t compact)
{
// Give the fraction of triggers (in triggerList) relative
// to what is expected in the scalers
{
std::cout << Form("RUN %09d ",srun->String().Atoi());
+ if (!compact) std::cout << std::endl;
+
nextTrigger.Reset();
while ( ( strigger = static_cast<TObjString*>(nextTrigger()) ) )
total += n;
totalExpected += expected;
- std::cout << Form("%20s %9lld expected %9lld ",strigger->String().Data(),n,expected);
+ std::cout << Form("%30s %9lld expected %9lld ",strigger->String().Data(),n,expected);
if ( expected > 0 ) {
std::cout << Form("fraction %5.1f %%",n*100.0/expected);
}
+ if (!compact)
+ {
+ std::cout << std::endl;
+ }
}
std::cout << std::endl;
}
if ( ok ) return runnumber;
return -1;
}
-
};
Result(TRootIOCtor* /*io*/) :
- TNamed("",""), fTriggerName(), fNofTriggers(), fHC(0x0), fRebin(0),
+ TNamed("",""),
+ fTriggerName(),
+ fEventSelection(),
+ fPairSelection(),
+ fCentralitySelection(),
+ fNofRuns(),
+ fNofTriggers(),
+ fHC(0x0), fRebin(0),
fFitTotal(0x0),
fMinv(0x0), fMinvLS(0),
fFitType(0), fMap(0x0)
{
}
- Result(const char* name, Int_t ntriggers, AliHistogramCollection* hc, Int_t nrebin=1, UInt_t fitType=(kJpsi | kJpsiPrime)) :
- TNamed("",""), fTriggerName(name), fNofTriggers(ntriggers), fHC(hc), fRebin(nrebin),
+ Result(const char* triggerClass,
+ const char* eventSelection,
+ const char* pairSelection,
+ const char* centSelection,
+ Int_t ntriggers, AliHistogramCollection* hc, Int_t nrebin=1, UInt_t fitType=(kJpsi | kJpsiPrime)) :
+ TNamed("",""), fTriggerName(triggerClass),
+ fEventSelection(eventSelection),
+ fPairSelection(pairSelection),
+ fCentralitySelection(centSelection),
+ fNofRuns(1),
+ fNofTriggers(ntriggers), fHC(hc), fRebin(nrebin),
fFitTotal(0x0),
fMinv(0x0), fMinvLS(0),
fFitType(fitType), fMap(0x0)
{
if (hc) Fit(nrebin);
}
-
+
virtual ~Result();
+
+ const char* GetName() const { return fTriggerName.Data(); }
AliHistogramCollection* HC() const { return fHC; }
- const char* TriggerClass() const { return fTriggerName.Data(); }
+ const char* TriggerClass() const { return GetName(); }
+
+ const char* EventSelection() const { return fEventSelection.Data(); }
+ const char* PairSelection() const { return fPairSelection.Data(); }
+ const char* CentralitySelection() const { return fCentralitySelection.Data(); }
Int_t NofTriggers() const { return fNofTriggers; }
UInt_t FitType() const { return fFitType; }
+ Int_t NofRuns() const { return fNofRuns; }
+
+ void SetNofRuns(int n) { fNofRuns=n; }
+
private:
Result(const Result&);
Result& operator=(const Result&);
private:
TString fTriggerName;
+ TString fEventSelection;
+ TString fPairSelection;
+ TString fCentralitySelection;
+ Int_t fNofRuns;
Int_t fNofTriggers;
AliHistogramCollection* fHC;
Int_t fRebin;
mutable TMap* fMap; // map of results (string,TObjArray) each TObjArray = (value,error) = (TParameter<double>, TParameter<double>)
- ClassDef(AliAnalysisMuMu::Result,5)
+ ClassDef(AliAnalysisMuMu::Result,7)
};
+ /* Basic checks */
+ void BasicCounts(Bool_t detailTrigger=kFALSE,
+ ULong64_t* totalNmb=0x0,
+ ULong64_t* totalNmsl=0x0,
+ ULong64_t* totalNmul=0x0);
- static TObjArray* ComputeBackgroundEvolution(const char* filelist, const char* trigger,
- const char* outputfile, const char* outputMode="UPDATE");
+ static void BasicCountsEvolution(const char* filelist, Bool_t detailTrigger=kFALSE);
+
+ void TriggerCountCoverage(const char* triggerList, Bool_t compact=kTRUE);
+
+
+ /** Background evolution functions */
+ static TObjArray* ComputeBackgroundEvolution(const char* filelist, const char* triggerList,
+ const char* outputfile="background-evolution.root", const char* outputMode="UPDATE");
+
+ static void PlotBackgroundEvolution(const char* gfile, const char* triggerList);
+
- void BasicCounts(Bool_t detailTrigger=kFALSE);
+ /** Fitting */
+ static TMap* ComputeJpsiEvolution(const char* filelist, const char* triggerList,
+ const char* outputFile="jpsi-evolution.root", const char* outputMode="UPDATE",
+ Bool_t simulation=kFALSE);
- void TriggerCountCoverage(const char* triggerList);
+ static void PlotJpsiEvolution(const char* resultFile, const char* triggerList, Bool_t fillBoundaries=kFALSE,
+ const char* efficiencyFile=0x0);
+ ///------
+
static void CentralityCheck(const char* filelist);
static TObjArray* CompareJpsiPerCMUUWithBackground(const char* jpsiresults="results.root",
AliCounterCollection& cc,
const char* base,
const char* selection,
- const char* trackcut,
const char* paircut,
const char* centrality,
UInt_t fitType,
static ULong64_t GetTriggerScalerCount(const char* triggerList, Int_t runNumber);
- static TObjArray* JpsiEvolution(const char* filelist, const char* output="res.root", Bool_t simulation=kFALSE);
-
TObjArray* Jpsi(Bool_t simulation=kFALSE);
- static void PlotBackgroundEvolution(const char* gfile, const char* triggerList);
-
static TObjArray* ReadFileList(const char* filelist);
static Int_t RunNumberFromFileName(const char* filename);
void SetDimuonTriggerList(const char* dimuonTriggerList) { fDimuonTriggers = dimuonTriggerList; }
void SetMuonTriggerList(const char* muonTriggerList) { fMuonTriggers = muonTriggerList; }
void SetMinbiasTriggerList(const char* minbiasTriggerList) { fMinbiasTriggers = minbiasTriggerList; }
+
+ TString DimuonTriggerList() const { return fDimuonTriggers; }
+ TString MuonTriggerList() const { return fMuonTriggers; }
+ TString MinbiasTriggerList() const { return fMinbiasTriggers; }
+
+ void SetEventSelectionList(const char* eventSelectionList) { fEventSelectionList = eventSelectionList; }
+ void SetPairSelectionList(const char* pairSelectionList) { fPairSelectionList = pairSelectionList; }
+
+ static void SetDefaultDimuonTriggerList(const char* dimuonTriggerList) { fgDefaultDimuonTriggers = dimuonTriggerList; }
+ static void SetDefaultMuonTriggerList(const char* muonTriggerList) { fgDefaultMuonTriggers = muonTriggerList; }
+ static void SetDefaultMinbiasTriggerList(const char* minbiasTriggerList) { fgDefaultMinbiasTriggers = minbiasTriggerList; }
+ static void SetDefaultEventSelectionList(const char* eventSelectionList) { fgDefaultEventSelectionList = eventSelectionList; }
+ static void SetDefaultPairSelectionList(const char* pairSelectionList) { fgDefaultPairSelectionList = pairSelectionList; }
+
AliHistogramCollection* HC() const { return fHistogramCollection; }
AliCounterCollection* CC() const { return fCounterCollection; }
static void SetOCDBPath(const char* ocdbPath) { fgOCDBPath = ocdbPath; }
static void SetColorScheme();
-
+
+ static void DrawFill(Int_t run1, Int_t run2, double ymin, double ymax, const char* label);
+
private:
static TString ExpandPathName(const char* file);
TString fDimuonTriggers; // list of dimuon triggers to consider
TString fMuonTriggers; // list of single muon triggers to consider
TString fMinbiasTriggers; // list of minbias triggers to consider
+ TString fEventSelectionList; // list of event types to consider
+ TString fPairSelectionList; // list of pair cuts to consider
static TString fgOCDBPath; // OCDB to be used (raw:// by default)
- ClassDef(AliAnalysisMuMu,1) // class to analysis results from AliAnalysisTaskMuMuXXX tasks
+ static TString fgDefaultMuonTriggers; // default list of single muon triggers
+ static TString fgDefaultMinbiasTriggers; // default list of MB triggers
+ static TString fgDefaultDimuonTriggers; // default list of dimuon triggers
+ static TString fgDefaultEventSelectionList; // default list of event selections
+ static TString fgDefaultPairSelectionList; // default list of pair selections
+
+ ClassDef(AliAnalysisMuMu,3) // class to analysis results from AliAnalysisTaskMuMuXXX tasks
};
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff