}
-
-//________________________________________________________
-void AliTRDalignmentTask::GetRefFigure(Int_t ifig)
-{
- AliInfo(Form("Reference plot [%d] missing result", ifig));
-}
-
-
//________________________________________________________
void AliTRDalignmentTask::Terminate(Option_t *)
{
void CreateOutputObjects();
void Exec(Option_t *opt);
- void GetRefFigure(Int_t ifig);
TObjArray* Histos();
TH1* PlotTrackPoints(const AliTRDtrackV1 *track=0x0);
Bool_t PostProcess(){return kTRUE;}
}
//_______________________________________________________
-void AliTRDcheckDetector::GetRefFigure(Int_t ifig){
+Bool_t AliTRDcheckDetector::GetRefFigure(Int_t ifig){
//
// Setting Reference Figures
//
((TH1F*)fContainer->At(kNTracksEventHist))->Draw("pl");
break;
}
+ return kTRUE;
}
//_______________________________________________________
TH1 *PlotChargeDeposit(const AliTRDtrackV1 *t = 0x0);
virtual Bool_t PostProcess();
- virtual void GetRefFigure(Int_t ifig);
+ virtual Bool_t GetRefFigure(Int_t ifig);
void SetRecoParam(AliTRDrecoParam *r);
}
//_______________________________________________________
-void AliTRDclusterResolution::GetRefFigure(Int_t ifig)
+Bool_t AliTRDclusterResolution::GetRefFigure(Int_t ifig)
{
- if(!fResults) return /*kFALSE*/;
+ if(!fResults) return kFALSE;
TObjArray *arr = 0x0;
TH2 *h2 = 0x0;
gs->Draw("apl");
gs->GetHistogram()->SetXTitle("Log(Q) [a.u.]");
gs->GetHistogram()->SetYTitle("#sigma_{y}^{2} [mm^{2}] [a.u.]");
- return /*kTRUE*/;
+ return kTRUE;
case kYRes:
if(!(arr = (TObjArray*)fResults->At(kYRes))) break;
if(!(gm = (TGraphErrors*)arr->At(0))) break;
gs->Draw("apl");
gs->GetHistogram()->SetXTitle("y [w]");
gs->GetHistogram()->SetYTitle("#sigma_{y}^{2} [mm^{2}] [a.u.]");
- return /*kTRUE*/;
+ return kTRUE;
case kSXRes:
if(!(h2 = (TH2F*)fResults->At(kSXRes))) break;
h2->Draw("lego2");
- return /*kTRUE*/;
+ return kTRUE;
case kSYRes:
if(!(h2 = (TH2F*)fResults->At(kSYRes))) break;
h2->Draw("lego2");
- return /*kTRUE*/;
+ return kTRUE;
default:
break;
}
- return /*kFALSE*/;
+ return kFALSE;
}
//_______________________________________________________
if((arr = (TObjArray*)fContainer->At(kSXRes))) {
for(Int_t id=1; id<=fAd->GetNbins(); id++){
d = fAd->GetBinCenter(id); //[mm]
- printf("Doing d=%f[mm]\n", d);
+ printf(" Doing d = %f[mm]\n", d);
for(Int_t it=1; it<=fAt->GetNbins(); it++){
x = fAt->GetBinCenter(it); //[mm]
- printf("Doing x=%f[mm]\n", x);
+ printf(" Doing xd = %f[mm]\n", x);
Int_t idx = (id-1)*kNTB+it-1;
if(!(h2 = (TH2I*)arr->At(idx))) {
AliWarning(Form("Missing histo at index idx[%3d] [id[%2d] it[%2d]] xd[%f] d[%f]\n", idx, id, it, x, d));
gs->SetPointError(ip, 0., 2.e2*f.GetParameter(2)*f.GetParError(2));
ip++;
}
+ if(ip<4) continue;
for(;ip<gm->GetN(); ip++){
gm->RemovePoint(ip);gs->RemovePoint(ip);
}
void CreateOutputObjects();
void Exec(Option_t *);
Float_t GetExB() const { return fExB;}
- void GetRefFigure(Int_t ifig);
+ Bool_t GetRefFigure(Int_t ifig);
TObjArray* Histos();
//________________________________________________________
-void AliTRDpidChecker::GetRefFigure(Int_t ifig)
+Bool_t AliTRDpidChecker::GetRefFigure(Int_t ifig)
{
Bool_t FIRST = kTRUE;
TLegend *leg = new TLegend(.7, .7, .98, .98);
gPad->SetLogx();
gPad->SetGridy();
gPad->SetGridx();
- return;
+ return kTRUE;
case kdEdx:
// save 2.0 GeV projection as reference
FIRST = kTRUE;
gPad->SetLogx(0);
gPad->SetGridy();
gPad->SetGridx();
- return;
+ return kTRUE;
case kdEdxSlice:
break;
case kPH:
gPad->SetLogx(0);
gPad->SetGridy();
gPad->SetGridx();
- return;
+ return kTRUE;
case kNClus:
// save 2.0 GeV projection as reference
FIRST = kTRUE;
gPad->SetLogx(0);
gPad->SetGridy();
gPad->SetGridx();
- return;
+ return kTRUE;
case kMomentum:
case kMomentumBin:
break;
gPad->SetLogx();
gPad->SetGridy();
gPad->SetGridx();
- return;
+ return kTRUE;
}
AliInfo(Form("Reference plot [%d] missing result", ifig));
+ return kFALSE;
}
//________________________________________________________________________
virtual ~AliTRDpidChecker();
virtual void CreateOutputObjects();
- virtual void GetRefFigure(Int_t ifig);
+ virtual Bool_t GetRefFigure(Int_t ifig);
virtual Bool_t PostProcess();
virtual void Terminate(Option_t *);
}
-//________________________________________________________
-void AliTRDpidRefMaker::GetRefFigure(Int_t /*ifig*/)
-{
-
-}
-
-
//________________________________________________________________________
Bool_t AliTRDpidRefMaker::PostProcess()
{
void CreateOutputObjects();
void Exec(Option_t *option);
- void GetRefFigure(Int_t ifig);
Int_t GetEpochs() {return fEpochs;};
Int_t GetMinTrain() {return fMinTrain;};
Int_t GetTrainMomBin() {return fTrainMomBin;};
}
//_______________________________________________________
-void AliTRDrecoTask::GetRefFigure(Int_t /*ifig*/)
+Bool_t AliTRDrecoTask::GetRefFigure(Int_t /*ifig*/)
{
AliWarning("Retrieving reference figures not implemented.");
+ return kFALSE;
}
//_______________________________________________________
Int_t GetDebugLevel() const { return fDebugLevel;}
Int_t GetNRefFigures() const { return fNRefFigures; }
TList* GetPlotFunctors() const { return fPlotFuncList;}
- virtual void GetRefFigure(Int_t ifig);
+ virtual Bool_t GetRefFigure(Int_t ifig);
Bool_t HasFriends() const {return TestBit(kFriends);};
Bool_t HasMCdata() const {return TestBit(kMCdata);};
//____________________________________________________________________
-void AliTRDtrackingEfficiency::GetRefFigure(Int_t ifig)
+Bool_t AliTRDtrackingEfficiency::GetRefFigure(Int_t ifig)
{
Bool_t FIRST = kTRUE;
TProfile *h = 0x0;
}
break;
}
+ return kTRUE;
}
virtual ~AliTRDtrackingEfficiency();
void CreateOutputObjects();
void Exec(Option_t *);
- void GetRefFigure(Int_t ifig);
+ Bool_t GetRefFigure(Int_t ifig);
Bool_t PostProcess();
void Terminate(Option_t *);
}
//_____________________________________________________________________________
-void AliTRDtrackingEfficiencyCombined::GetRefFigure(Int_t ifig){
+Bool_t AliTRDtrackingEfficiencyCombined::GetRefFigure(Int_t ifig){
//
// Plot the histograms
//
- if(ifig >= fNRefFigures) return;
+ if(ifig >= fNRefFigures) return kFALSE;
if(ifig < 2){
(dynamic_cast<TH1 *>(fContainer->At(ifig)))->Draw("e1");
- return;
+ return kTRUE;
}
switch(ifig){
- case 2:
- (dynamic_cast<TH1 *>(fContainer->At(kEfficiencySpeciesHistogram)))->Draw("e1");
- for(Int_t ispec = 1; ispec < AliPID::kSPECIES; ispec++)
- (dynamic_cast<TH1 *>(fContainer->At(kEfficiencySpeciesHistogram + ispec)))->Draw("e1same");
- break;
- case 3:
- (dynamic_cast<TH1 *>(fContainer->At(kContaminationSpeciesHistogram)))->Draw("e1");
- for(Int_t ispec = 1; ispec < AliPID::kSPECIES; ispec++)
- (dynamic_cast<TH1 *>(fContainer->At(kContaminationSpeciesHistogram + ispec)))->Draw("e1same");
- break;
- case 4:
- (dynamic_cast<TH1 *>(fContainer->At(kEfficiencyNoPID)))->Draw("e1");
- break;
- case 5:
- (dynamic_cast<TH1 *>(fContainer->At(kContaminationNoPID)))->Draw("e1");
- break;
+ case 2:
+ (dynamic_cast<TH1 *>(fContainer->At(kEfficiencySpeciesHistogram)))->Draw("e1");
+ for(Int_t ispec = 1; ispec < AliPID::kSPECIES; ispec++)
+ (dynamic_cast<TH1 *>(fContainer->At(kEfficiencySpeciesHistogram + ispec)))->Draw("e1same");
+ break;
+ case 3:
+ (dynamic_cast<TH1 *>(fContainer->At(kContaminationSpeciesHistogram)))->Draw("e1");
+ for(Int_t ispec = 1; ispec < AliPID::kSPECIES; ispec++)
+ (dynamic_cast<TH1 *>(fContainer->At(kContaminationSpeciesHistogram + ispec)))->Draw("e1same");
+ break;
+ case 4:
+ (dynamic_cast<TH1 *>(fContainer->At(kEfficiencyNoPID)))->Draw("e1");
+ break;
+ case 5:
+ (dynamic_cast<TH1 *>(fContainer->At(kContaminationNoPID)))->Draw("e1");
+ break;
}
+ return kTRUE;
}
//_____________________________________________________________________________
AliTRDtrackingEfficiencyCombined();
virtual ~AliTRDtrackingEfficiencyCombined(){;}
- virtual void CreateOutputObjects();
- virtual void Exec(Option_t *);
- virtual void Terminate(Option_t *);
+ void CreateOutputObjects();
+ void Exec(Option_t *);
+ void Terminate(Option_t *);
- virtual Bool_t PostProcess();
- virtual TObjArray *Histos();
- void GetRefFigure(Int_t ifig);
+ Bool_t PostProcess();
+ TObjArray* Histos();
+ Bool_t GetRefFigure(Int_t ifig);
private:
enum{
//________________________________________________________
-void AliTRDtrackingResolution::GetRefFigure(Int_t ifig)
+Bool_t AliTRDtrackingResolution::GetRefFigure(Int_t ifig)
{
TBox *b = 0x0;
TAxis *ax = 0x0;
b = new TBox(-.15, -.5, .15, 1.);
b->SetFillStyle(3002);b->SetFillColor(kGreen);
b->SetLineColor(0); b->Draw();
- return;
+ return kTRUE;
case kTrackletYResidual:
if(!(g = (TGraphErrors*)fGraphS->At(ifig))) break;
g->Draw("apl");
b = new TBox(-.15, -.5, .15, 1.);
b->SetFillStyle(3002);b->SetFillColor(kGreen);
b->SetLineColor(0); b->Draw();
- return;
+ return kTRUE;
case kTrackletPhiResidual:
if(!(g = (TGraphErrors*)fGraphS->At(ifig))) break;
g->Draw("apl");
b = new TBox(-.15, -.5, .15, 1.);
b->SetFillStyle(3002);b->SetFillColor(kGreen);
b->SetLineColor(0); b->Draw();
- return;
+ return kTRUE;
case kClusterResolution:
if(!(g = (TGraphErrors*)fGraphS->At(ifig))) break;
ax = g->GetHistogram()->GetYaxis();
b = new TBox(-.15, -.5, .15, 1.);
b->SetFillStyle(3002);b->SetFillColor(kGreen);
b->SetLineColor(0); b->Draw();
- return;
+ return kTRUE;
case kTrackletYResolution:
if(!(g = (TGraphErrors*)fGraphS->At(ifig))) break;
ax = g->GetHistogram()->GetYaxis();
g->Draw("apl");
if(!(g = (TGraphErrors*)fGraphM->At(ifig))) break;
g->Draw("pl");
- return;
+ return kTRUE;
case kTrackletZResolution:
if(!(g = (TGraphErrors*)fGraphS->At(ifig))) break;
ax = g->GetHistogram()->GetYaxis();
g->Draw("apl");
if(!(g = (TGraphErrors*)fGraphM->At(ifig))) break;
g->Draw("pl");
- return;
+ return kTRUE;
case kTrackletAngleResolution:
if(!(g = (TGraphErrors*)fGraphS->At(ifig))) break;
ax = g->GetHistogram()->GetYaxis();
g->Draw("apl");
if(!(g = (TGraphErrors*)fGraphM->At(ifig))) break;
g->Draw("pl");
- return;
+ return kTRUE;
default:
AliInfo(Form("Reference plot [%d] not implemented yet", ifig));
- return;
+ return kFALSE;
}
AliInfo(Form("Reference plot [%d] missing result", ifig));
+ return kFALSE;
}
virtual ~AliTRDtrackingResolution();
void CreateOutputObjects();
- void GetRefFigure(Int_t ifig);
+ Bool_t GetRefFigure(Int_t ifig);
TObjArray* Histos();
void Exec(Option_t *);
Bool_t IsVerbose() const {return TESTBIT(fStatus, kVerbose);}
#include <TGraph.h>
#include <TObjArray.h>
#include <TObjString.h>
-#include <TPython.h>
#include <TString.h>
#include <TROOT.h>
#include <TSystem.h>
#include "run.h"
-Char_t *libs[] = {"libProofPlayer.so", "libANALYSIS.so", "libTRDqaRec.so", "libPyROOT"};
+Char_t *libs[] = {"libProofPlayer.so", "libANALYSIS.so", "libTRDqaRec.so"};
-void makeResults(Char_t *args = "ALL")
+void makeResults(Char_t *opt = "ALL", const Char_t *files=0x0)
{
// Load Libraries in interactive mode
Int_t nlibs = static_cast<Int_t>(sizeof(libs)/sizeof(Char_t *));
Bool_t mc = kTRUE;
Bool_t friends = kTRUE;
- const Char_t *dir = 0x0;
- TString tasks;
- TObjArray *argsArray = TString(args).Tokenize("?");
- switch(argsArray->GetEntriesFast()){
- case 1:
- tasks = ((TObjString*)(*argsArray)[0])->String();
- dir=0x0;
- break;
- case 2:
- tasks = ((TObjString*)(*argsArray)[0])->String();
- dir = ((TObjString*)(*argsArray)[1])->GetName();
- break;
- default:
- printf("Macro accepts 2 arguments separated by a '?'.\n");
- printf("arg #1 : list of tasks/options\n");
- printf("arg #2 : list of files to be processed\n");
- return;
- }
-
// select tasks to process; we should move it to an
// individual function and move the task identifiers
// outside the const space
+ TString tasks(opt);
TObjArray *tasksArray = tasks.Tokenize(" ");
Int_t fSteerTask = 0;
for(Int_t isel = 0; isel < tasksArray->GetEntriesFast(); isel++){
TString s = (dynamic_cast<TObjString *>(tasksArray->UncheckedAt(isel)))->String();
if(s.CompareTo("ALL") == 0){
- for(Int_t itask = 1; itask < NTRDTASKS; itask++) SETBIT(fSteerTask, itask - 1);
+ for(Int_t itask = 1; itask < NQATASKS; itask++) SETBIT(fSteerTask, itask);
continue;
} else if(s.CompareTo("NOFR") == 0){
friends = kFALSE;
Bool_t foundOpt = kFALSE;
for(Int_t itask = 1; itask < NTRDTASKS; itask++){
if(s.CompareTo(fgkTRDtaskOpt[itask]) != 0) continue;
- SETBIT(fSteerTask, itask - 1);
+ SETBIT(fSteerTask, itask);
foundOpt = kTRUE;
break;
}
if(!foundOpt) Info("makeResults.C", Form("Task %s not implemented (yet).", s.Data()));
}
}
+ // extra rules for calibration tasks
+ if(TSTBIT(fSteerTask, kClErrParam)) SETBIT(fSteerTask, kResolution);
+ if(TSTBIT(fSteerTask, kPIDRefMaker)) SETBIT(fSteerTask, kPIDChecker);
+ if(TSTBIT(fSteerTask, kAlignment)) SETBIT(fSteerTask, kResolution);
// file merger object
- TFileMerger *fFM = new TFileMerger();
+ TFileMerger *fFM = 0x0;
TClass *ctask = 0x0;
AliTRDrecoTask *task = 0x0;
Int_t nFiles;
if(gSystem->AccessPathName(Form("%s/merge", gSystem->ExpandPathName("$PWD")))) gSystem->Exec(Form("mkdir -v %s/merge", gSystem->ExpandPathName("$PWD")));
- printf("\n\tPROCESSING DATA FOR TASKS [%b]:\n", fSteerTask);
- for(Int_t itask = 0; itask <NTRDTASKS; itask++){
+ for(Int_t itask = 1; itask<NTRDTASKS; itask++){
if(!TSTBIT(fSteerTask, itask)) continue;
ctask = new TClass(fgkTRDtaskClassName[itask]);
task->SetFriends(friends);
// setup filelist
- string filename;
nFiles = 0;
- ifstream filestream(dir);
- while(getline(filestream, filename)){
- if(Int_t(filename.find(task->GetName())) < 0) continue;
- if(Int_t(filename.find("merge")) >= 0) continue;
- nFiles++;
+ string filename;
+ if(files){
+ ifstream filestream(files);
+ while(getline(filestream, filename)){
+ if(Int_t(filename.find(task->GetName())) < 0) continue;
+ if(Int_t(filename.find("merge")) >= 0) continue;
+ nFiles++;
+ }
+ } else {
+ nFiles = !gSystem->AccessPathName(Form("TRD.Task%s.root", task->GetName()));
}
+
if(!nFiles){
- printf("No Files found for Task %s\n", task->GetName());
+ Info("makeResults.C", Form("No Files found for Task %s", task->GetName()));
delete task;
delete ctask;
continue;
}
- printf("Processing %d files for task %s ...\n", nFiles, task->GetName());
+ Info("makeResults.C", Form(" Processing %d files for task %s ...", nFiles, task->GetName()));
- ifstream file(dir);
- if(nFiles>1){
- fFM = new(fFM) TFileMerger(kTRUE);
+ if(files){
+ fFM = new TFileMerger(kTRUE);
fFM->OutputFile(Form("%s/merge/TRD.Task%s.root", gSystem->ExpandPathName("$PWD"), task->GetName()));
+ ifstream file(files);
while(getline(file, filename)){
if(Int_t(filename.find(task->GetName())) < 0) continue;
if(Int_t(filename.find("merge")) >= 0) continue;
fFM->AddFile(filename.c_str());
}
fFM->Merge();
- fFM->~TFileMerger();
+ delete fFM;
task->Load(Form("%s/merge/TRD.Task%s.root", gSystem->ExpandPathName("$PWD"), task->GetName()));
} else{
- getline(file, filename);
- task->Load(filename.c_str());
+ task->Load(Form("%s/TRD.Task%s.root", gSystem->ExpandPathName("$PWD"), task->GetName()));
}
task->PostProcess();
TCanvas *c=new TCanvas();
for(Int_t ipic=0; ipic<task->GetNRefFigures(); ipic++){
- task->GetRefFigure(ipic);
+ if(!task->GetRefFigure(ipic)) return;
c->SaveAs(Form("%s_fig%d.gif", task->GetName(), ipic));
c->Clear();
}
// Steer TRD QA train for Reconstruction (Clusterizer, Tracking and PID).
//
// Usage:
-// run.C(tasks, files, entries)
+// run.C(tasks, files)
// tasks : "ALL" or one/more of the following:
// "EFF" : TRD Tracking Efficiency
// "EFFC" : TRD Tracking Efficiency Combined (barrel + stand alone) - only in case of simulations
// gSystem->Load("libMemStatGui.so")
// gSystem->Load("libANALYSIS.so")
// gSystem->Load("libTRDqaRec.so")
+// gSystem->Load("libNetx.so") ;
+// gSystem->Load("libRAliEn.so");
//
// Authors:
// Alex Bercuci (A.Bercuci@gsi.de)
#include "TSystem.h"
#include "TError.h"
#include "TChain.h"
+#include "TGrid.h"
+#include "TAlienCollection.h"
+#include "TGridCollection.h"
+#include "TGridResult.h"
#include "AliMagFMaps.h"
#include "AliTracker.h"
#include "AliLog.h"
#include "AliCDBManager.h"
+#include "AliGeomManager.h"
#include "AliAnalysisManager.h"
#include "AliAnalysisDataContainer.h"
#include "AliMCEventHandler.h"
#include "TRD/qaRec/AliTRDtrackingEfficiencyCombined.h"
#include "TRD/qaRec/AliTRDtrackingResolution.h"
#include "TRD/qaRec/AliTRDcalibration.h"
+#include "TRD/qaRec/AliTRDalignmentTask.h"
#include "TRD/qaRec/AliTRDpidChecker.h"
#include "TRD/qaRec/AliTRDpidRefMaker.h"
#include "TRD/qaRec/AliTRDcheckDetector.h"
Bool_t MEM = kFALSE;
-TChain* CreateESDChain(const char* filename = 0x0, Int_t nfiles=-1 );
-void run(Char_t *tasks="ALL", const Char_t *files=0x0, Int_t nmax=-1)
+TChain* MakeChainLST(const char* filename = 0x0);
+TChain* MakeChainXML(const char* filename = 0x0);
+void run(Char_t *tasks="ALL", const Char_t *files=0x0)
{
TMemStat *mem = 0x0;
if(MEM){
for(Int_t isel = 0; isel < tasksArray->GetEntriesFast(); isel++){
TString s = (dynamic_cast<TObjString *>(tasksArray->UncheckedAt(isel)))->String();
if(s.CompareTo("ALL") == 0){
- for(Int_t itask = 1; itask <= NTRDTASKS; itask++) SETBIT(fSteerTask, itask);
+ for(Int_t itask = 1; itask < NQATASKS; itask++) SETBIT(fSteerTask, itask);
continue;
} else if(s.CompareTo("NOFR") == 0){
fHasFriends = kFALSE;
fHasMCdata = kFALSE;
} else {
Bool_t foundOpt = kFALSE;
- for(Int_t itask = 1; itask <= NTRDTASKS; itask++){
+ for(Int_t itask = 1; itask < NTRDTASKS; itask++){
if(s.CompareTo(fgkTRDtaskOpt[itask]) != 0) continue;
SETBIT(fSteerTask, itask);
foundOpt = kTRUE;
}
}
// extra rules for calibration tasks
- if(TSTBIT(fSteerTask, kClusterErrorParam)) SETBIT(fSteerTask, kTrackingResolution);
+ if(TSTBIT(fSteerTask, kClErrParam)) SETBIT(fSteerTask, kResolution);
+ if(TSTBIT(fSteerTask, kPIDRefMaker)) SETBIT(fSteerTask, kPIDChecker);
+ if(TSTBIT(fSteerTask, kAlignment)) SETBIT(fSteerTask, kResolution);
// define task list pointers;
- AliTRDrecoTask *taskPtr[2*NTRDTASKS], *task = 0x0;
- memset(taskPtr, 0, 2*NTRDTASKS*sizeof(AliAnalysisTask*));
+ AliTRDrecoTask *taskPtr[NTRDTASKS], *task = 0x0;
+ memset(taskPtr, 0, NTRDTASKS*sizeof(AliAnalysisTask*));
//____________________________________________//
- //gROOT->LoadMacro(Form("%s/TRD/qaRec/CreateESDChain.C", gSystem->ExpandPathName("$ALICE_ROOT")));
- TChain *chain = CreateESDChain(files, nmax);
+ // DEFINE DATA CHAIN
+ TChain *chain = 0x0;
+ if(!files) chain = MakeChainLST();
+ else{
+ TString fn(files);
+ if(fn.EndsWith("xml")) chain = MakeChainXML(files);
+ else chain = MakeChainLST(files);
+ }
+ if(!chain) return;
+
//chain->SetBranchStatus("*", 0);
chain->SetBranchStatus("*FMD*",0);
chain->SetBranchStatus("*Calo*",0);
//____________________________________________
// TRD barrel tracking efficiency
- if(fHasMCdata && TSTBIT(fSteerTask, kTrackingEfficiency)){
+ if(fHasMCdata && TSTBIT(fSteerTask, kTrackingEff)){
mgr->AddTask(task = new AliTRDtrackingEfficiency());
- taskPtr[(Int_t)kTrackingEfficiency] = task;
+ taskPtr[(Int_t)kTrackingEff] = task;
task->SetDebugLevel(0);
//Create containers for input/output
//____________________________________________
// TRD combined tracking efficiency
- if(fHasMCdata && TSTBIT(fSteerTask, kTrackingCombinedEfficiency)){
+ if(fHasMCdata && TSTBIT(fSteerTask, kTrackingEffMC)){
mgr->AddTask(task = new AliTRDtrackingEfficiencyCombined());
- taskPtr[(Int_t)kTrackingCombinedEfficiency] = task;
+ taskPtr[(Int_t)kTrackingEffMC] = task;
task->SetDebugLevel(0);
// Create containers for input/output
//____________________________________________
// TRD tracking resolution
- if(TSTBIT(fSteerTask, kTrackingResolution)){
+ if(TSTBIT(fSteerTask, kResolution)){
mgr->AddTask(task = new AliTRDtrackingResolution());
- taskPtr[(Int_t)kTrackingResolution] = task;
+ taskPtr[(Int_t)kResolution] = task;
task->SetMCdata(fHasMCdata);
task->SetPostProcess(kFALSE);
task->SetDebugLevel(1);
// Create output containers for calibration tasks
const Int_t nc = 5;
- const Char_t *cn[nc] = {"ClRez", "TrkltRez", "TrkltPhiRez", "ClRes", "TrkltRes"};
+ const Char_t *cn[nc] = {"Cl", "TrkltY", "TrkltPhi", "ClMC", "TrkltYMC"};
AliAnalysisDataContainer *co[nc];
for(Int_t ic = 0; ic<nc; ic++){
co[ic] = mgr->CreateContainer(Form("%s%s", task->GetName(), cn[ic]), TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
}
// test reconstruction calibration plugin
- if(TSTBIT(fSteerTask, kClusterErrorParam)){
+ if(TSTBIT(fSteerTask, kClErrParam)){
mgr->AddTask(task = new AliTRDclusterResolution());
- taskPtr[(Int_t)kClusterErrorParam] = task;
+ taskPtr[(Int_t)kClErrParam] = task;
mgr->ConnectInput(task, 0, co[0]);
mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
mgr->AddTask(task = new AliTRDclusterResolution());
- taskPtr[(Int_t)kClusterErrorParam+1] = task;
- mgr->ConnectInput(task, 0, co[1]);
+ taskPtr[(Int_t)kClErrParam+1] = task;
+ mgr->ConnectInput(task, 0, co[3]);
mgr->ConnectOutput(task, 0, mgr->CreateContainer(Form("%sMC", task->GetName()), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%sMC.root", task->GetName())));
}
}
}
//____________________________________________
- // TRD pid checker
+ // TRD PID
if(TSTBIT(fSteerTask, kPIDChecker)){
mgr->AddTask(task = new AliTRDpidChecker());
taskPtr[(Int_t)kPIDChecker] = task;
// Create containers for input/output
mgr->ConnectInput( task, 0, coutput1);
mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
- }
-
- //____________________________________________
- // TRD pid reference
- if(TSTBIT(fSteerTask, kPIDRefMaker)){
- mgr->AddTask(task = new AliTRDpidRefMaker());
- taskPtr[(Int_t)kPIDRefMaker] = task;
- task->SetDebugLevel(0);
- task->SetMCdata(fHasMCdata);
-
- // Create containers for input/output
- mgr->ConnectInput( task, 0, coutput1);
- mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
- mgr->ConnectOutput(task, 1, mgr->CreateContainer(Form("%sNN", task->GetName()), TTree::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%sNN.root", task->GetName())));
- mgr->ConnectOutput(task, 2, mgr->CreateContainer(Form("%sLQ", task->GetName()), TTree::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%sLQ.root", task->GetName())));
+ //____________________________________________
+ // TRD pid reference
+ if(TSTBIT(fSteerTask, kPIDRefMaker)){
+ mgr->AddTask(task = new AliTRDpidRefMaker());
+ taskPtr[(Int_t)kPIDRefMaker] = task;
+ task->SetDebugLevel(0);
+ task->SetMCdata(fHasMCdata);
+
+ // Create containers for input/output
+ mgr->ConnectInput( task, 0, coutput1);
+ mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
+ mgr->ConnectOutput(task, 1, mgr->CreateContainer(Form("%sNN", task->GetName()), TTree::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%sNN.root", task->GetName())));
+ mgr->ConnectOutput(task, 2, mgr->CreateContainer(Form("%sLQ", task->GetName()), TTree::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%sLQ.root", task->GetName())));
+ }
}
if (!mgr->InitAnalysis()) return;
printf("\n\tRUNNING TRAIN FOR TASKS:\n");
- for(Int_t itask = 1; itask <= NTRDTASKS; itask++){
- if(TSTBIT(fSteerTask, itask)) printf("\t %s [%s]\n", taskPtr[itask]->GetTitle(), taskPtr[itask]->GetName());
+ for(Int_t itask = 1; itask < NTRDTASKS; itask++){
+ if(TSTBIT(fSteerTask, itask)) printf("\t %s [%s]\n", taskPtr[itask]->GetName(), taskPtr[itask]->GetTitle());
}
printf("\n\n");
//mgr->PrintStatus();
AliCDBManager *cdbManager = AliCDBManager::Instance();
cdbManager->SetDefaultStorage("local://$ALICE_ROOT");
- //cdbManager->SetSpecificStorage("TRD/Calib/FEE","local:///u/bailhach/aliroot/database30head/database");
cdbManager->SetRun(0);
cdbManager->SetCacheFlag(kFALSE);
cal->Terminate();
delete field;
delete cdbManager;
- for(Int_t it=2*NTRDTASKS; it--; ){
- if(taskPtr[it]) delete taskPtr[it];
+ for(Int_t it=NTRDTASKS; it--; ){
+ if(taskPtr[it]){
+ printf("Cleaning %s [%s] ...\n", fgkTRDtaskClassName[it], taskPtr[it]->GetTitle());
+ delete taskPtr[it];
+ }
}
if(mcH) delete mcH;
delete esdH;
if(MEM) TMemStatViewerGUI::ShowGUI();
}
-
-TChain* CreateESDChain(const char* filename, Int_t nfiles)
+//____________________________________________
+TChain* MakeChainLST(const char* filename)
{
// Create the chain
TChain* chain = new TChain("esdTree");
ifstream in;
in.open(filename);
TString esdfile;
- while(in.good() && (nfiles--) ) {
+ while(in.good()) {
in >> esdfile;
if (!esdfile.Contains("root")) continue; // protection
chain->Add(esdfile.Data());
return chain;
}
+
+//____________________________________________
+TChain* MakeChainXML(const char* xmlfile)
+{
+ if (!TFile::Open(xmlfile)) {
+ Error("MakeChainXML", Form("No file %s was found", xmlfile));
+ return 0x0;
+ }
+
+ if(gSystem->Load("libNetx.so")<0) return 0x0;
+ if(gSystem->Load("libRAliEn.so")<0) return 0x0;
+ TGrid::Connect("alien://") ;
+
+ TGridCollection *collection = (TGridCollection*) TAlienCollection::Open(xmlfile);
+ if (!collection) {
+ Error("MakeChainXML", Form("No collection found in %s", xmlfile)) ;
+ return 0x0;
+ }
+ //collection->CheckIfOnline();
+
+ TGridResult* result = collection->GetGridResult("",0 ,0);
+ if(!result->GetEntries()){
+ Error("MakeChainXML", Form("No entries found in %s", xmlfile)) ;
+ return 0x0;
+ }
+ // Makes the ESD chain
+ TChain* chain = new TChain("esdTree");
+ for (Int_t idx = 0; idx < result->GetEntries(); idx++) {
+ chain->Add(result->GetKey(idx, "turl"));
+ }
+ return chain;
+}
#define TSTBIT(n,i) ((Bool_t)(((n) & BIT(i)) != 0))
#define CLRBIT(n,i) ((n) &= ~BIT(i))
-#define NTRDTASKS 9
+#define NQATASKS 6
+#define NCALIBTASKS 4
+const Int_t NTRDTASKS = NQATASKS+NCALIBTASKS;
enum AliTRDrecoTasks{
kInfoGen = 0
,kCheckDetector = 1
- ,kTrackingEfficiency = 2
- ,kTrackingCombinedEfficiency = 3
- ,kTrackingResolution = 4
- ,kCalibration = 5
- ,kAlignment = 6
- ,kPIDChecker = 7
+ ,kTrackingEff = 2
+ ,kTrackingEffMC = 3
+ ,kResolution = 4
+ ,kPIDChecker = 5
+ ,kCalibration = 6
+ ,kAlignment = 7
,kPIDRefMaker = 8
- ,kClusterErrorParam = 9
+ ,kClErrParam = 9
};
-const Char_t* fgkTRDtaskClassName[NTRDTASKS] = {
- "AliTRDcheckDetector"
+const Char_t* fgkTRDtaskClassName[NQATASKS+NCALIBTASKS] = {
+ "AliTRDtrackInfoGen"
+ ,"AliTRDcheckDetector"
,"AliTRDtrackingEfficiency"
,"AliTRDtrackingEfficiencyCombined"
,"AliTRDtrackingResolution"
+ ,"AliTRDpidChecker"
,"AliTRDcalibration"
,"AliTRDalignmentTask"
- ,"AliTRDpidChecker"
,"AliTRDpidRefMaker"
,"AliTRDclusterResolution"
};
-const Char_t *fgkTRDtaskOpt[NTRDTASKS+3] = {
+const Char_t *fgkTRDtaskOpt[NQATASKS+NCALIBTASKS+2] = {
"ALL"
,"DET"
,"EFF"
,"EFFC"
,"RES"
+ ,"PID"
,"CAL"
,"ALGN"
- ,"PID"
,"PIDR"
,"CLRES"
,"NOFR"
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff