#include "info/AliTRDtrackInfo.h"
#include "info/AliTRDeventInfo.h"
-#include "AliTRDcheckDetector.h"
+#include "AliTRDcheckDET.h"
#include <cstdio>
#include <iostream>
////////////////////////////////////////////////////////////////////////////
//_______________________________________________________
-AliTRDcheckDetector::AliTRDcheckDetector():
- AliTRDrecoTask("DetChecker", "Basic Detector Checker")
+AliTRDcheckDET::AliTRDcheckDET():
+ AliTRDrecoTask("checkDET", "Basic TRD data checker")
,fEventInfo(0x0)
,fTriggerNames(0x0)
,fReconstructor(0x0)
}
//_______________________________________________________
-AliTRDcheckDetector::~AliTRDcheckDetector(){
+AliTRDcheckDET::~AliTRDcheckDET(){
//
// Destructor
//
}
//_______________________________________________________
-void AliTRDcheckDetector::ConnectInputData(Option_t *opt){
+void AliTRDcheckDET::ConnectInputData(Option_t *opt){
//
// Connect the Input data with the task
//
}
//_______________________________________________________
-void AliTRDcheckDetector::CreateOutputObjects(){
+void AliTRDcheckDET::CreateOutputObjects(){
//
// Create Output Objects
//
}
//_______________________________________________________
-void AliTRDcheckDetector::Exec(Option_t *opt){
+void AliTRDcheckDET::Exec(Option_t *opt){
//
// Execution function
// Filling TRD quality histos
}
//_______________________________________________________
-void AliTRDcheckDetector::Terminate(Option_t *){
+void AliTRDcheckDET::Terminate(Option_t *){
//
// Terminate function
//
}
//_______________________________________________________
-Bool_t AliTRDcheckDetector::PostProcess(){
+Bool_t AliTRDcheckDET::PostProcess(){
//
// Do Postprocessing (for the moment set the number of Reference histograms)
//
}
//_______________________________________________________
-Bool_t AliTRDcheckDetector::GetRefFigure(Int_t ifig){
+Bool_t AliTRDcheckDET::GetRefFigure(Int_t ifig){
//
// Setting Reference Figures
//
}
//_______________________________________________________
-TObjArray *AliTRDcheckDetector::Histos(){
+TObjArray *AliTRDcheckDET::Histos(){
//
// Create QA histograms
//
*/
//_______________________________________________________
-TH1 *AliTRDcheckDetector::PlotNClustersTracklet(const AliTRDtrackV1 *track){
+TH1 *AliTRDcheckDET::PlotNClustersTracklet(const AliTRDtrackV1 *track){
//
// Plot the mean number of clusters per tracklet
//
}
//_______________________________________________________
-TH1 *AliTRDcheckDetector::PlotNClustersTrack(const AliTRDtrackV1 *track){
+TH1 *AliTRDcheckDET::PlotNClustersTrack(const AliTRDtrackV1 *track){
//
// Plot the number of clusters in one track
//
//_______________________________________________________
-TH1 *AliTRDcheckDetector::PlotNTrackletsTrack(const AliTRDtrackV1 *track){
+TH1 *AliTRDcheckDET::PlotNTrackletsTrack(const AliTRDtrackV1 *track){
//
// Plot the number of tracklets
//
//_______________________________________________________
-TH1 *AliTRDcheckDetector::PlotNTrackletsRowCross(const AliTRDtrackV1 *track){
+TH1 *AliTRDcheckDET::PlotNTrackletsRowCross(const AliTRDtrackV1 *track){
//
// Plot the number of tracklets
//
}
//_______________________________________________________
-TH1 *AliTRDcheckDetector::PlotFindableTracklets(const AliTRDtrackV1 *track){
+TH1 *AliTRDcheckDET::PlotFindableTracklets(const AliTRDtrackV1 *track){
//
// Plots the ratio of number of tracklets vs.
// number of findable tracklets
//_______________________________________________________
-TH1 *AliTRDcheckDetector::PlotChi2(const AliTRDtrackV1 *track){
+TH1 *AliTRDcheckDET::PlotChi2(const AliTRDtrackV1 *track){
//
// Plot the chi2 of the track
//
}
//_______________________________________________________
-TH1 *AliTRDcheckDetector::PlotChi2Norm(const AliTRDtrackV1 *track){
+TH1 *AliTRDcheckDET::PlotChi2Norm(const AliTRDtrackV1 *track){
//
// Plot the chi2 of the track
//
//_______________________________________________________
-TH1 *AliTRDcheckDetector::PlotPHt(const AliTRDtrackV1 *track){
+TH1 *AliTRDcheckDET::PlotPHt(const AliTRDtrackV1 *track){
//
// Plot the average pulse height
//
}
//_______________________________________________________
-TH1 *AliTRDcheckDetector::PlotPHx(const AliTRDtrackV1 *track){
+TH1 *AliTRDcheckDET::PlotPHx(const AliTRDtrackV1 *track){
//
// Plots the average pulse height vs the distance from the anode wire
// (plus const anode wire offset)
}
//_______________________________________________________
-TH1 *AliTRDcheckDetector::PlotChargeCluster(const AliTRDtrackV1 *track){
+TH1 *AliTRDcheckDET::PlotChargeCluster(const AliTRDtrackV1 *track){
//
// Plot the cluster charge
//
}
//_______________________________________________________
-TH1 *AliTRDcheckDetector::PlotChargeTracklet(const AliTRDtrackV1 *track){
+TH1 *AliTRDcheckDET::PlotChargeTracklet(const AliTRDtrackV1 *track){
//
// Plot the charge deposit per chamber
//
}
//_______________________________________________________
-TH1 *AliTRDcheckDetector::PlotNTracksSector(const AliTRDtrackV1 *track){
+TH1 *AliTRDcheckDET::PlotNTracksSector(const AliTRDtrackV1 *track){
//
// Plot the number of tracks per Sector
//
//________________________________________________________
-void AliTRDcheckDetector::SetRecoParam(AliTRDrecoParam *r)
+void AliTRDcheckDET::SetRecoParam(AliTRDrecoParam *r)
{
fReconstructor->SetRecoParam(r);
}
//________________________________________________________
-void AliTRDcheckDetector::GetDistanceToTracklet(Double_t *dist, AliTRDseedV1 *tracklet, AliTRDcluster *c)
+void AliTRDcheckDET::GetDistanceToTracklet(Double_t *dist, AliTRDseedV1 *tracklet, AliTRDcluster *c)
{
Float_t x = c->GetX();
dist[0] = c->GetY() - tracklet->GetYat(x);
}
//________________________________________________________
-void AliTRDcheckDetector::MakePlotNTracklets(){
+void AliTRDcheckDET::MakePlotNTracklets(){
//
// Make nice bar plot of the number of tracklets in each method
//
}
//________________________________________________________
-void AliTRDcheckDetector::MakePlotPulseHeight(){
+void AliTRDcheckDET::MakePlotPulseHeight(){
//
// Create Plot of the Pluse Height Spectrum
//
}
//________________________________________________________
-Bool_t AliTRDcheckDetector::MakeBarPlot(TH1 *histo, Int_t color){
+Bool_t AliTRDcheckDET::MakeBarPlot(TH1 *histo, Int_t color){
//
// Draw nice bar plots
//
-#ifndef ALITRDCHECKDETECTOR_H
-#define ALITRDCHECKDETECTOR_H
+#ifndef ALITRDCHECKDET_H
+#define ALITRDCHECKDET_H
#ifndef ALITRDRECOTASK_H
#include "AliTRDrecoTask.h"
class AliTRDReconstructor;
class AliTRDrecoParam;
class AliTRDeventInfo;
-
-class AliTRDcheckDetector : public AliTRDrecoTask{
+class AliTRDcheckDET : public AliTRDrecoTask{
public:
// The Histogram number
enum HistType_t {
kNclustersTrack = 0,
- kNclustersTracklet = 1,
+ kNclustersTracklet = 1,
kNtrackletsTrack = 2,
kNtrackletsSTA = 3,
kNtrackletsBAR = 4,
kTriggerPurity = 15
};
- AliTRDcheckDetector();
- virtual ~AliTRDcheckDetector();
+ AliTRDcheckDET();
+ virtual ~AliTRDcheckDET();
virtual void ConnectInputData(const Option_t *);
virtual void CreateOutputObjects();
void SetRecoParam(AliTRDrecoParam *r);
private:
- AliTRDcheckDetector(const AliTRDcheckDetector &);
- AliTRDcheckDetector& operator=(const AliTRDcheckDetector &);
+ AliTRDcheckDET(const AliTRDcheckDET &);
+ AliTRDcheckDET& operator=(const AliTRDcheckDET &);
void GetDistanceToTracklet(Double_t *dist, AliTRDseedV1 *tracklet, AliTRDcluster *c);
void MakePlotNTracklets();
void MakePlotPulseHeight();
AliTRDReconstructor *fReconstructor; // TRD Reconstructor
AliTRDgeometry *fGeo; // TRD Geometry object
- ClassDef(AliTRDcheckDetector, 1)
+ ClassDef(AliTRDcheckDET, 1)
};
#endif
//____________________________________________________________________
AliTRDcheckESD::AliTRDcheckESD():
- AliAnalysisTask("ESDchecker", "ESD checker for TRD info")
+ AliAnalysisTask("checkESD", "ESD checker for TRD info")
,fStatus(0)
,fESD(0x0)
,fMC(0x0)
#include "AliCDBManager.h"
#include "AliTRDpidUtil.h"
-#include "AliTRDpidChecker.h"
+#include "AliTRDcheckPID.h"
#include "info/AliTRDtrackInfo.h"
// calculate pion efficiency at 90% electron efficiency for 11 momentum bins
// this task should be used with simulated data only
-ClassImp(AliTRDpidChecker)
+ClassImp(AliTRDcheckPID)
//________________________________________________________________________
-AliTRDpidChecker::AliTRDpidChecker()
- :AliTRDrecoTask("PID", "PID Checker")
+AliTRDcheckPID::AliTRDcheckPID()
+ :AliTRDrecoTask("checkPID", "TRD PID checker")
,fReconstructor(0x0)
,fUtil(0x0)
,fGraph(0x0)
//________________________________________________________________________
-AliTRDpidChecker::~AliTRDpidChecker()
+AliTRDcheckPID::~AliTRDcheckPID()
{
if(fGraph){fGraph->Delete(); delete fGraph;}
if(fReconstructor) delete fReconstructor;
//________________________________________________________________________
-void AliTRDpidChecker::CreateOutputObjects()
+void AliTRDcheckPID::CreateOutputObjects()
{
// Create histograms
// Called once
//_______________________________________________________
-TObjArray * AliTRDpidChecker::Histos(){
+TObjArray * AliTRDcheckPID::Histos(){
//
// Create QA histograms
//________________________________________________________________________
-Bool_t AliTRDpidChecker::CheckTrackQuality(const AliTRDtrackV1* track)
+Bool_t AliTRDcheckPID::CheckTrackQuality(const AliTRDtrackV1* track)
{
//
// Check if the track is ok for PID
}
//________________________________________________________________________
-Int_t AliTRDpidChecker::CalcPDG(AliTRDtrackV1* track)
+Int_t AliTRDcheckPID::CalcPDG(AliTRDtrackV1* track)
{
track -> SetReconstructor(fReconstructor);
//_______________________________________________________
-TH1 *AliTRDpidChecker::PlotLQ(const AliTRDtrackV1 *track)
+TH1 *AliTRDcheckPID::PlotLQ(const AliTRDtrackV1 *track)
{
//
// Plot the probabilities for electrons using 2-dim LQ
//_______________________________________________________
-TH1 *AliTRDpidChecker::PlotNN(const AliTRDtrackV1 *track)
+TH1 *AliTRDcheckPID::PlotNN(const AliTRDtrackV1 *track)
{
//
// Plot the probabilities for electrons using 2-dim LQ
//_______________________________________________________
-TH1 *AliTRDpidChecker::PlotESD(const AliTRDtrackV1 *track)
+TH1 *AliTRDcheckPID::PlotESD(const AliTRDtrackV1 *track)
{
//
// Plot the probabilities for electrons using 2-dim LQ
//_______________________________________________________
-TH1 *AliTRDpidChecker::PlotdEdx(const AliTRDtrackV1 *track)
+TH1 *AliTRDcheckPID::PlotdEdx(const AliTRDtrackV1 *track)
{
//
// Plot the probabilities for electrons using 2-dim LQ
//_______________________________________________________
-TH1 *AliTRDpidChecker::PlotdEdxSlice(const AliTRDtrackV1 *track)
+TH1 *AliTRDcheckPID::PlotdEdxSlice(const AliTRDtrackV1 *track)
{
//
// Plot the probabilities for electrons using 2-dim LQ
//_______________________________________________________
-TH1 *AliTRDpidChecker::PlotPH(const AliTRDtrackV1 *track)
+TH1 *AliTRDcheckPID::PlotPH(const AliTRDtrackV1 *track)
{
//
// Plot the probabilities for electrons using 2-dim LQ
//_______________________________________________________
-TH1 *AliTRDpidChecker::PlotNClus(const AliTRDtrackV1 *track)
+TH1 *AliTRDcheckPID::PlotNClus(const AliTRDtrackV1 *track)
{
//
// Plot the probabilities for electrons using 2-dim LQ
}
//_______________________________________________________
-TH1 *AliTRDpidChecker::PlotNTracklets(const AliTRDtrackV1 *track)
+TH1 *AliTRDcheckPID::PlotNTracklets(const AliTRDtrackV1 *track)
{
//
// Plot the probabilities for electrons using 2-dim LQ
}
//_______________________________________________________
-TH1 *AliTRDpidChecker::PlotMom(const AliTRDtrackV1 *track)
+TH1 *AliTRDcheckPID::PlotMom(const AliTRDtrackV1 *track)
{
//
// Plot the probabilities for electrons using 2-dim LQ
//_______________________________________________________
-TH1 *AliTRDpidChecker::PlotMomBin(const AliTRDtrackV1 *track)
+TH1 *AliTRDcheckPID::PlotMomBin(const AliTRDtrackV1 *track)
{
//
// Plot the probabilities for electrons using 2-dim LQ
//________________________________________________________
-Bool_t AliTRDpidChecker::GetRefFigure(Int_t ifig)
+Bool_t AliTRDcheckPID::GetRefFigure(Int_t ifig)
{
Bool_t FIRST = kTRUE;
TGraphErrors *g = 0x0;
}
//________________________________________________________________________
-Bool_t AliTRDpidChecker::PostProcess()
+Bool_t AliTRDcheckPID::PostProcess()
{
// Draw result to the screen
// Called once at the end of the query
}
//________________________________________________________________________
-void AliTRDpidChecker::EvaluatePionEfficiency(TObjArray *histoContainer, TObjArray *results, Float_t electron_efficiency){
+void AliTRDcheckPID::EvaluatePionEfficiency(TObjArray *histoContainer, TObjArray *results, Float_t electron_efficiency){
fUtil->SetElectronEfficiency(electron_efficiency);
Color_t colors[3] = {kBlue, kGreen+2, kRed};
}
//________________________________________________________________________
-void AliTRDpidChecker::Terminate(Option_t *)
+void AliTRDcheckPID::Terminate(Option_t *)
{
// Draw result to the screen
// Called once at the end of the query
-#ifndef ALITRDPIDCHECKER_H
-#define ALITRDPIDCHECKER_H
+#ifndef ALITRDCHECKPID_H
+#define ALITRDCHECKPID_H
//////////////////////////////////////////////////////
//
class AliTRDReconstructor;
class AliTRDpidUtil;
-class AliTRDpidChecker : public AliTRDrecoTask
+class AliTRDcheckPID : public AliTRDrecoTask
{
// Plots registered for this task
enum{
,kNPlots = 9 // Number of plots for this tasks
};
public:
- AliTRDpidChecker();
- virtual ~AliTRDpidChecker();
+ AliTRDcheckPID();
+ virtual ~AliTRDcheckPID();
virtual void CreateOutputObjects();
virtual Bool_t GetRefFigure(Int_t ifig);
inline Bool_t IsInRange(Double_t momentum);
private:
- AliTRDpidChecker(const AliTRDpidChecker&); // not implemented
- AliTRDpidChecker& operator=(const AliTRDpidChecker&); // not implemented
+ AliTRDcheckPID(const AliTRDcheckPID&); // not implemented
+ AliTRDcheckPID& operator=(const AliTRDcheckPID&); // not implemented
Int_t CalcPDG(AliTRDtrackV1* track = 0x0);
Bool_t CheckTrackQuality(const AliTRDtrackV1* track = 0x0);
TAxis *fMomentumAxis; //! helper mementum binning
Int_t fMinNTracklets; // minimum number of required Tracklets (for systematic studies)
Int_t fMaxNTracklets; // maximum number of required Tracklets (for systematic studies)
- ClassDef(AliTRDpidChecker, 1); // TRD PID checker
+ ClassDef(AliTRDcheckPID, 1); // TRD PID checker
};
//________________________________________________________________________
-inline void AliTRDpidChecker::SetMomentumBinning(Int_t nBins, Double_t *bins){
+inline void AliTRDcheckPID::SetMomentumBinning(Int_t nBins, Double_t *bins){
//
// Set the Momentum Bins
//
}
//________________________________________________________________________
-inline Int_t AliTRDpidChecker::FindBin(Int_t species, Double_t momentum){
+inline Int_t AliTRDcheckPID::FindBin(Int_t species, Double_t momentum){
//
// Find the Bin in the 2D Histogram
//
}
//________________________________________________________________________
-inline Bool_t AliTRDpidChecker::IsInRange(Double_t momentum){
+inline Bool_t AliTRDcheckPID::IsInRange(Double_t momentum){
//
// Check Whether momentum is in the defined Range
//
//____________________________________________________________________
AliTRDefficiency::AliTRDefficiency()
- :AliTRDrecoTask("Efficiency", "Barrel Tracking Efficiency")
+ :AliTRDrecoTask("efficiency", "TRD barrel tracking efficiency checker")
,fMissed(0x0)
{
//
//____________________________________________________________________
AliTRDinfoGen::AliTRDinfoGen():
- AliTRDrecoTask("InfoGen", "Track List Generator")
+ AliTRDrecoTask("infoGen", "MC-REC TRD-track list generator")
,fESD(0x0)
,fMC(0x0)
,fESDfriend(0x0)
//________________________________________________________
AliTRDresolution::AliTRDresolution()
- :AliTRDrecoTask("Resolution", "Spatial and Momentum Resolution")
+ :AliTRDrecoTask("resolution", "Spatial and momentum TRD resolution checker")
,fStatus(0)
,fReconstructor(0x0)
,fGeo(0x0)
#if ! defined (__CINT__) || defined (__MAKECINT__)
#include "AliAnalysisManager.h"
#include "AliAnalysisDataContainer.h"
-#include "TRD/qaRec/run.h"
+#include "TRD/qaRec/macros/AliTRDperformanceTrain.h"
#include "TRD/qaRec/AliTRDefficiency.h"
#include "TRD/qaRec/AliTRDefficiencyMC.h"
#include "TRD/qaRec/AliTRDmultiplicity.h"
#endif
-void AddTRDefficiency(AliAnalysisManager *mgr, AliAnalysisDataContainer **ci, AliAnalysisDataContainer **/*co*/, Int_t map)
+void AddTRDefficiency(AliAnalysisManager *mgr, Char_t *trd, AliAnalysisDataContainer **ci/*, AliAnalysisDataContainer **co*/)
{
+ Int_t map = ParseOptions(trd);
+ if(!(TSTBIT(map, kEfficiency))) return;
+
Bool_t mc = mgr->GetMCtruthEventHandler();
AliTRDefficiency *eff = 0x0;
mgr->AddTask(eff = new AliTRDefficiency());
#include "AliAnalysisDataContainer.h"
#include "TRD/qaRec/AliTRDinfoGen.h"
#include "TRD/qaRec/info/AliTRDeventInfo.h"
+#include "TRD/qaRec/macros/AliTRDperformanceTrain.h"
#endif
-void AddTRDinfoGen(AliAnalysisManager *mgr, AliAnalysisDataContainer **/*ci*/, AliAnalysisDataContainer **co)
+void AddTRDinfoGen(AliAnalysisManager *mgr, Char_t *trd, AliAnalysisDataContainer **/*ci*/, AliAnalysisDataContainer **co)
{
+ Int_t map = ParseOptions(trd);
+ if(!(TSTBIT(map, kInfoGen))) return;
+
AliTRDinfoGen *info = 0x0;
mgr->AddTask(info = new AliTRDinfoGen());
info->SetDebugLevel(0);
#include "TTree.h"
#include "AliAnalysisManager.h"
#include "AliAnalysisDataContainer.h"
-#include "TRD/qaRec/run.h"
+#include "TRD/qaRec/macros/AliTRDperformanceTrain.h"
#include "TRD/qaRec/AliTRDresolution.h"
#include "TRD/qaRec/AliTRDclusterResolution.h"
#include "TRD/qaRec/AliTRDalignmentTask.h"
#endif
-void AddTRDresolution(AliAnalysisManager *mgr, AliAnalysisDataContainer **ci, AliAnalysisDataContainer **co, Int_t map)
+void AddTRDresolution(AliAnalysisManager *mgr, Char_t *trd, AliAnalysisDataContainer **ci/*, AliAnalysisDataContainer **co*/)
{
+ Int_t map = ParseOptions(trd);
+ if(!(TSTBIT(map, kResolution))) return;
+
AliTRDresolution *task = 0x0;
mgr->AddTask(task = new AliTRDresolution());
task->SetMCdata(mgr->GetMCtruthEventHandler());
// Create output containers for calibration tasks
const Int_t nc = 4;
const Char_t *cn[nc] = {"Cl", "Trklt", "MC_Cl", "MC_Trklt"};
+ AliAnalysisDataContainer *co[] = {0x0, 0x0, 0x0, 0x0};
for(Int_t ic = 0; ic<nc; ic++){
co[ic] = mgr->CreateContainer(Form("%s%s", task->GetName(), cn[ic]), TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
mgr->ConnectOutput(task, 1+ic, co[ic]);
--- /dev/null
+#ifndef ALITRDPERFORMANCETRAIN_H
+#define ALITRDPERFORMANCETRAIN_H
+
+#define BIT(n) (1 << (n))
+#define SETBIT(n,i) ((n) |= BIT(i))
+#define TSTBIT(n,i) ((Bool_t)(((n) & BIT(i)) != 0))
+#define CLRBIT(n,i) ((n) &= ~BIT(i))
+
+#define NTRDQATASKS 6
+#define NTRDCALIBTASKS 6
+const Int_t NTRDTASKS = NTRDQATASKS+NTRDCALIBTASKS;
+
+enum AliTRDrecoTasks{
+ kCheckESD = 0
+ ,kInfoGen = 1
+ ,kCheckDET = 2
+ ,kEfficiency = 3
+ ,kResolution = 4
+ ,kCheckPID = 5
+ ,kCalibration = 6
+ ,kEfficiencyMC = 7
+ ,kAlignment = 8
+ ,kPIDRefMaker = 9
+ ,kClErrParam =10
+ ,kMultiplicity =11
+};
+
+const Char_t* fgkTRDtaskClassName[NTRDTASKS] = {
+ "AliTRDcheckESD"
+ ,"AliTRDinfoGen"
+ ,"AliTRDcheckDET"
+ ,"AliTRDefficiency"
+ ,"AliTRDresolution"
+ ,"AliTRDcheckPID"
+ ,"AliTRDcalibration"
+ ,"AliTRDefficiencyMC"
+ ,"AliTRDalignmentTask"
+ ,"AliTRDpidRefMaker"
+ ,"AliTRDclusterResolution"
+ ,"AliTRDmultiplicity"
+};
+
+const Char_t *fgkTRDtaskOpt[NTRDTASKS+1] = {
+ ""
+ ,"GEN"
+ ,"DET"
+ ,"EFF"
+ ,"RES"
+ ,"PID"
+ ,"CAL"
+ ,"EFFC"
+ ,"ALGN"
+ ,"PIDR"
+ ,"CLRES"
+ ,"MULT"
+ ,"ALL"
+};
+
+#if ! defined (__CINT__) || defined (__MAKECINT__)
+#include "TString.h"
+#include "TObjString.h"
+#include "TObjArray.h"
+#include "TError.h"
+#endif
+
+//____________________________________________
+Int_t ParseOptions(Char_t *trd)
+{
+ Int_t fSteerTask = 1;
+ TObjArray *tasksArray = TString(trd).Tokenize(" ");
+ 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 = 0; itask < NTRDQATASKS; itask++) SETBIT(fSteerTask, itask);
+ continue;
+ } else {
+ Bool_t foundOpt = kFALSE;
+ for(Int_t itask = 2; itask < NTRDTASKS; itask++){
+ if(s.CompareTo(fgkTRDtaskOpt[itask]) != 0) continue;
+ SETBIT(fSteerTask, itask); SETBIT(fSteerTask, kInfoGen);
+ foundOpt = kTRUE;
+ break;
+ }
+ if(!foundOpt) Info("run.C", Form("TRD task %s not implemented (yet).", s.Data()));
+ }
+ }
+ // extra rules for calibration tasks
+ if(TSTBIT(fSteerTask, kCalibration)) SETBIT(fSteerTask, kCheckDET);
+ if(TSTBIT(fSteerTask, kMultiplicity)) SETBIT(fSteerTask, kEfficiency);
+ if(TSTBIT(fSteerTask, kEfficiencyMC)) SETBIT(fSteerTask, kEfficiency);
+ if(TSTBIT(fSteerTask, kClErrParam)) SETBIT(fSteerTask, kResolution);
+ if(TSTBIT(fSteerTask, kAlignment)) SETBIT(fSteerTask, kResolution);
+ if(TSTBIT(fSteerTask, kPIDRefMaker)) SETBIT(fSteerTask, kCheckPID);
+
+ return fSteerTask;
+}
+
+
+#endif
+
#include "TRD/AliTRDtrackerV1.h"
#include "TRD/AliTRDcalibDB.h"
-#include "TRD/qaRec/info/AliTRDeventInfo.h"
-#include "TRD/qaRec/AliTRDcheckESD.h"
-#include "TRD/qaRec/AliTRDinfoGen.h"
-#include "TRD/qaRec/AliTRDefficiency.h"
-#include "TRD/qaRec/AliTRDefficiencyMC.h"
-#include "TRD/qaRec/AliTRDresolution.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"
-#include "TRD/qaRec/AliTRDclusterResolution.h"
-#include "TRD/qaRec/AliTRDmultiplicity.h"
-
-
-#include "PWG1/AliPerformanceTask.h"
-#include "PWG1/AliPerformanceEff.h"
-#include "PWG1/AliPerformanceDEdx.h"
-#include "PWG1/AliPerformanceTPC.h"
-#include "PWG1/AliPerformanceDCA.h"
-#include "PWG1/AliPerformanceRes.h"
-#include "PWG1/AliMCInfoCuts.h"
-#include "PWG1/AliRecInfoCuts.h"
+
+#include "TRD/qaRec/macros/AddTRDcheckESD.C"
+#include "TRD/qaRec/macros/AddTRDinfoGen.C"
+#include "TRD/qaRec/macros/AddTRDcheckDET.C"
+#include "TRD/qaRec/macros/AddTRDefficiency.C"
+#include "TRD/qaRec/macros/AddTRDresolution.C"
+#include "TRD/qaRec/macros/AddTRDcheckPID.C"
+
#endif
-#include "run.h"
+#include "macros/AliTRDperformanceTrain.h"
+#include "../../PWG1/macros/AddPerformanceTask.C"
+
Bool_t MEM = kFALSE;
Bool_t fHasMCdata = kTRUE;
Bool_t fHasFriends = kTRUE;
-const Int_t kTPCmode = 0; //
-const Int_t kTPChpt = 0; //
TChain* MakeChainLST(const char* filename = 0x0);
TChain* MakeChainXML(const char* filename = 0x0);
-Int_t ParseTRD(Char_t *opt);
-Int_t ParseTPC(Char_t *opt);
void run(Char_t *trd="ALL", Char_t *tpc="ALL", const Char_t *files=0x0, Long64_t nev=1234567890, Long64_t first = 0)
{
TMemStat *mem = 0x0;
if(gSystem->Load("libANALYSIS.so")<0) return;
if(gSystem->Load("libANALYSISalice.so")<0) return;
-
+/* } else if(s.CompareTo("NOFR") == 0){
+ fHasFriends = kFALSE;
+ } else if(s.CompareTo("NOMC") == 0){
+ fHasMCdata = kFALSE;
+*/
// INITIALIZATION OF RUNNING ENVIRONMENT
//TODO We should use the GRP if available similar to AliReconstruction::InitGRP()!
cdbManager->SetRun(0);
cdbManager->SetCacheFlag(kFALSE);
// initialize magnetic field.
- AliMagF *field = 0x0;
- field = new AliMagF("Maps","Maps", 2, 1., 10., AliMagF::k5kG);
- //field = new AliMagF("Maps","Maps", 2, 0., 10., AliMagF::k2kG);
- TGeoGlobalMagField::Instance()->SetField(field);
-
- // initialize TRD settings
- AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
- AliTRDtrackerV1::SetNTimeBins(cal->GetNumberOfTimeBins());
- AliGeomManager::LoadGeometry();
-
-
+ if(!TGeoGlobalMagField::Instance()->GetField()){
+ TGeoGlobalMagField::Instance()->SetField(
+ new AliMagF("Maps","Maps", 2, 1., 10., AliMagF::k5kG)
+ //AliMagF("Maps","Maps", 2, 0., 10., AliMagF::k2kG);
+ );
+ AliGeomManager::LoadGeometry();
+ }
// DEFINE DATA CHAIN
chain->Lookup();
chain->GetListOfFiles()->Print();
printf("\n ----> CHAIN HAS %d ENTRIES <----\n\n", (Int_t)chain->GetEntries());
-
// BUILD ANALYSIS MANAGER
///////////////////////////////////////////////////////////
// TRD specific library
if(gSystem->Load("libTRDqaRec.so")<0) return;
- // Parse TRD options
- Int_t fSteerTRD = ParseTRD(trd);
// TRD data containers
AliAnalysisDataContainer *ci[] = {0x0, 0x0};
- AliAnalysisDataContainer *co[] = {0x0, 0x0, 0x0, 0x0};
- // plug (set of) TRD wagons in the train
- for(Int_t it=0; it<NQATASKS; it++){
- if(!(TSTBIT(fSteerTRD, it))) continue;
- if(gROOT->LoadMacro(Form("$ALICE_ROOT/TRD/qaRec/macros/Add%s.C+", TString(fgkTRDtaskClassName[it])(3,20).Data()))) {
- Error("run.C", Form("Error loading %s task.", fgkTRDtaskClassName[it]));
- return;
- }
- switch(it){
- case kCheckESD:
- AddTRDcheckESD(mgr); break;
- case kInfoGen:
- AddTRDinfoGen(mgr, 0x0, ci); break;
- case kCheckDetector:
- AddTRDcheckDetector(mgr, ci, co, fSteerTRD); break;
- case kEfficiency:
- AddTRDefficiency(mgr, ci, co, fSteerTRD); break;
- case kResolution:
- AddTRDresolution(mgr, ci, co, fSteerTRD); break;
- case kPID:
- AddTRDpidChecker(mgr, ci, co, fSteerTRD); break;
- default:
- Warning("run.C", Form("No performance task registered at slot %d.", it));
+ // initialize TRD settings
+ AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
+ AliTRDtrackerV1::SetNTimeBins(cal->GetNumberOfTimeBins());
+
+ // plug (set of) TRD wagons in the train
+ if(trd){
+ for(Int_t it=0; it<NTRDQATASKS; it++){
+ if(gROOT->LoadMacro(Form("$ALICE_ROOT/TRD/qaRec/macros/Add%s.C+", TString(fgkTRDtaskClassName[it])(3,20).Data()))) {
+ Error("run.C", Form("Error loading %s task.", fgkTRDtaskClassName[it]));
+ return;
+ }
+
+ switch(it){
+ case kCheckESD:
+ AddTRDcheckESD(mgr); break;
+ case kInfoGen:
+ AddTRDinfoGen(mgr, trd, 0x0, ci); break;
+ case kCheckDET:
+ AddTRDcheckDET(mgr, trd, ci); break;
+ case kEfficiency:
+ AddTRDefficiency(mgr, trd, ci); break;
+ case kResolution:
+ AddTRDresolution(mgr, trd, ci); break;
+ case kCheckPID:
+ AddTRDcheckPID(mgr, trd, ci); break;
+ default:
+ Warning("run.C", Form("No performance task registered at slot %d.", it));
+ }
}
}
-
///////////////////////////////////////////////////////////
/////////////// TPC ///////////
///////////////////////////////////////////////////////////
if(gSystem->Load("libPWG1.so")<0) return;
- // Parse TPC options
- Int_t fSteerTPC = ParseTPC(tpc);
- // Create TPC-ESD track reconstruction cuts
- AliRecInfoCuts *pRecInfoCuts = new AliRecInfoCuts();
- pRecInfoCuts->SetPtRange(0.20,200.0);
- //pRecInfoCuts->SetEtaRange(-0.9,0.9);
- pRecInfoCuts->SetMaxDCAToVertexXY(3.0);
- pRecInfoCuts->SetMaxDCAToVertexZ(3.0);
- pRecInfoCuts->SetMinNClustersTPC(50);
- pRecInfoCuts->SetMinNClustersITS(2);
- pRecInfoCuts->SetMinTPCsignalN(50);
- pRecInfoCuts->SetHistogramsOn(kFALSE);
- // Create TPC-MC track reconstruction cuts
- AliMCInfoCuts *pMCInfoCuts = new AliMCInfoCuts();
- pMCInfoCuts->SetMinRowsWithDigits(50);
- pMCInfoCuts->SetMaxR(0.025); // from diamond xy size (pp@10TeV)
- pMCInfoCuts->SetMaxVz(15.); // from diamond z size (pp@10TeV)
- pMCInfoCuts->SetRangeTPCSignal(0.5,1.4);
- pMCInfoCuts->SetMinTrackLength(70);
// BUILD STEERING TASK FOR TPC
- if(fSteerTPC){
+ if(tpc){
if(gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddPerformanceTask.C+")) {
Error("run.C", "Error loading AliPerformanceTask task.");
return;
}
- AliPerformanceTask *TPC = AddPerformanceTask(mgr);
-
- // plug (set of) TPC wagons in the train
- TClass ctask; AliPerformanceObject *perf = 0x0;
- for(Int_t icomp=1; icomp<NTPCTASKS; icomp++){
- if(!(TSTBIT(fSteerTPC, icomp))) continue;
- new(&ctask) TClass(fgkTPCtaskClassName[icomp]);
- TPC->AddPerformanceObject((perf = (AliPerformanceObject*)ctask.New()));
- perf->SetAnalysisMode(kTPCmode);
- perf->SetHptGenerator(kTPChpt);
- perf->SetAliRecInfoCuts(pRecInfoCuts);
- perf->SetAliMCInfoCuts(pMCInfoCuts);
- }
+ AddPerformanceTask(mgr, tpc);
}
if (!mgr->InitAnalysis()) return;
}
return chain;
}
-
-
-//____________________________________________
-Int_t ParseTRD(Char_t *trd)
-{
- Int_t fSteerTask = 1;
- TObjArray *tasksArray = TString(trd).Tokenize(" ");
- 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 = 0; itask < NQATASKS; itask++) SETBIT(fSteerTask, itask);
- continue;
- } else if(s.CompareTo("NOFR") == 0){
- fHasFriends = kFALSE;
- } else if(s.CompareTo("NOMC") == 0){
- fHasMCdata = kFALSE;
- } else {
- Bool_t foundOpt = kFALSE;
- for(Int_t itask = 2; itask < NTRDTASKS; itask++){
- if(s.CompareTo(fgkTRDtaskOpt[itask]) != 0) continue;
- SETBIT(fSteerTask, itask); SETBIT(fSteerTask, kInfoGen);
- foundOpt = kTRUE;
- break;
- }
- if(!foundOpt) Info("run.C", Form("TRD task %s not implemented (yet).", s.Data()));
- }
- }
- // extra rules for calibration tasks
- if(TSTBIT(fSteerTask, kCalibration)) SETBIT(fSteerTask, kCheckDetector);
- if(TSTBIT(fSteerTask, kMultiplicity)) SETBIT(fSteerTask, kEfficiency);
- if(TSTBIT(fSteerTask, kEfficiencyMC)) SETBIT(fSteerTask, kEfficiency);
- if(TSTBIT(fSteerTask, kClErrParam)) SETBIT(fSteerTask, kResolution);
- if(TSTBIT(fSteerTask, kAlignment)) SETBIT(fSteerTask, kResolution);
- if(TSTBIT(fSteerTask, kPIDRefMaker)) SETBIT(fSteerTask, kPIDChecker);
-
- return fSteerTask;
-}
-
-
-
-//____________________________________________
-Int_t ParseTPC(Char_t *tpc)
-{
- Int_t fSteerTask = 0;
- TObjArray *tasksArray = TString(tpc).Tokenize(" ");
- 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 = 0; itask < NTPCPERFORMANCE; itask++) SETBIT(fSteerTask, itask);
- continue;
- } else if(s.CompareTo("NOFR") == 0){
- fHasFriends = kFALSE;
- } else if(s.CompareTo("NOMC") == 0){
- fHasMCdata = kFALSE;
- } else {
- Bool_t foundOpt = kFALSE;
- for(Int_t itask = 0; itask < NTPCTASKS; itask++){
- if(s.CompareTo(fgkTPCtaskOpt[itask]) != 0) continue;
- SETBIT(fSteerTask, itask); SETBIT(fSteerTask, 0);
- foundOpt = kTRUE;
- break;
- }
- if(!foundOpt) Info("run.C", Form("TPC task %s not implemented (yet).", s.Data()));
- }
- }
- return fSteerTask;
-}
-
-
+++ /dev/null
-#ifndef TRDRECONSTRUCTIONTRAIN_H
-#define TRDRECONSTRUCTIONTRAIN_H
-
-#define BIT(n) (1 << (n))
-#define SETBIT(n,i) ((n) |= BIT(i))
-#define TSTBIT(n,i) ((Bool_t)(((n) & BIT(i)) != 0))
-#define CLRBIT(n,i) ((n) &= ~BIT(i))
-
-#define NQATASKS 6
-#define NCALIBTASKS 6
-const Int_t NTRDTASKS = NQATASKS+NCALIBTASKS;
-
-enum AliTRDrecoTasks{
- kCheckESD = 0
- ,kInfoGen = 1
- ,kCheckDetector = 2
- ,kEfficiency = 3
- ,kResolution = 4
- ,kPID = 5
- ,kCalibration = 6
- ,kEfficiencyMC = 7
- ,kAlignment = 8
- ,kPIDRefMaker = 9
- ,kClErrParam =10
- ,kMultiplicity =11
-};
-
-const Char_t* fgkTRDtaskClassName[NQATASKS+NCALIBTASKS] = {
- "AliTRDcheckESD"
- ,"AliTRDinfoGen"
- ,"AliTRDcheckDetector"
- ,"AliTRDefficiency"
- ,"AliTRDresolution"
- ,"AliTRDpidChecker"
- ,"AliTRDcalibration"
- ,"AliTRDefficiencyMC"
- ,"AliTRDalignmentTask"
- ,"AliTRDpidRefMaker"
- ,"AliTRDclusterResolution"
- ,"AliTRDmultiplicity"
-};
-
-const Char_t *fgkTRDtaskOpt[NQATASKS+NCALIBTASKS+1] = {
- ""
- ,"GEN"
- ,"DET"
- ,"EFF"
- ,"RES"
- ,"PID"
- ,"CAL"
- ,"EFFC"
- ,"ALGN"
- ,"PIDR"
- ,"CLRES"
- ,"MULT"
- ,"ALL"
-};
-
-#define NTPCPERFORMANCE 6
-#define NTPCCALIBRATION 0
-const Int_t NTPCTASKS = NTPCPERFORMANCE+NTPCCALIBRATION;
-
-Char_t *fgkTPCtaskClassName[NTPCTASKS] = {
- "AliPerformanceTask"
- ,"AliPerformanceEff"
- ,"AliPerformanceRes"
- ,"AliPerformanceTPC"
- ,"AliPerformanceDEdx"
- ,"AliPerformanceDCA"
-};
-
-const Char_t *fgkTPCtaskOpt[NTPCTASKS+1] = {
- "GEN"
- ,"EFF"
- ,"RES"
- ,"TPC"
- ,"DEDX"
- ,"DCA"
- ,"ALL"
-};
-#endif
-
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff