//________________________________________________________
AliTRDalignmentTask::AliTRDalignmentTask()
- :AliTRDrecoTask("Alignment", "TRD alignment")
+ :AliTRDrecoTask()
,fTree(0x0)
,fArray(0x0)
{
InitFunctorList();
- DefineOutput(1, TTree::Class());
+}
+AliTRDalignmentTask::AliTRDalignmentTask(char* name)
+ :AliTRDrecoTask(name, "TRD alignment")
+ ,fTree(0x0)
+ ,fArray(0x0)
+{
+ InitFunctorList();
+ DefineOutput(2, TTree::Class());
}
//________________________________________________________
//________________________________________________________
-void AliTRDalignmentTask::CreateOutputObjects()
+void AliTRDalignmentTask::UserCreateOutputObjects()
{
// spatial resolution
- OpenFile(1, "RECREATE");
+ OpenFile(2, "RECREATE");
fTree = new TTree("spTree", "Tree with track space point arrays");
fTree->Branch("SP","AliTrackPointArray", &fArray);
//________________________________________________________
-void AliTRDalignmentTask::Exec(Option_t *opt)
+void AliTRDalignmentTask::UserExec(Option_t *opt)
{
// Documentation to come
AliTRDrecoTask::Exec(opt);
- PostData(1, fTree);
+ PostData(2, fTree);
}
public:
AliTRDalignmentTask();
+ AliTRDalignmentTask(char* name);
virtual ~AliTRDalignmentTask();
- void CreateOutputObjects();
- void Exec(Option_t *opt);
+ void UserCreateOutputObjects();
+ void UserExec(Option_t *opt);
TH1* PlotTrackPoints(const AliTRDtrackV1 *track=0x0);
Bool_t PostProcess() { return kTRUE;}
//________________________________________________________________________
AliTRDcalibration::AliTRDcalibration()
- :AliTRDrecoTask("Calibration", "Calibration on tracks")
+ :AliTRDrecoTask()
,fTrackInfo(0)
,ftrdTrack(0)
,fcl(0)
}
}
+
+AliTRDcalibration::AliTRDcalibration(char* name)
+ :AliTRDrecoTask(name, "Calibration on tracks")
+ ,fTrackInfo(0)
+ ,ftrdTrack(0)
+ ,fcl(0)
+ ,fTRDCalibraFillHisto(0)
+ ,fNbTRDTrack(0)
+ ,fNbTRDTrackOffline(0)
+ ,fNbTRDTrackStandalone(0)
+ ,fNbTRDTracklet(0)
+ ,fNbTRDTrackletOffline(0)
+ ,fNbTRDTrackletStandalone(0)
+ ,fNbTimeBin(0x0)
+ ,fNbTimeBinOffline(0x0)
+ ,fNbTimeBinStandalone(0x0)
+ ,fNbClusters(0)
+ ,fNbClustersOffline(0)
+ ,fNbClustersStandalone(0)
+ ,fPHSM(0)
+ ,fCHSM(0)
+ ,fPHSum(0)
+ ,fCHSum(0)
+ ,fDetSum(0)
+ ,fDetSumVector(0)
+ ,fHisto2d(kTRUE)
+ ,fVector2d(kFALSE)
+ ,fVdriftLinear(kTRUE)
+ ,flow(0)
+ ,fhigh(30)
+ ,fNbTimeBins(0)
+ ,ffillZero(kFALSE)
+ ,fnormalizeNbOfCluster(kFALSE)
+ ,fmaxCluster(0)
+ ,fOfflineTracks(kFALSE)
+ ,fStandaloneTracks(kFALSE)
+ ,fCompressPerDetector(kFALSE)
+ ,fGraph(0x0)
+ ,fArrayCalib(0x0)
+ ,fPostProcess(kFALSE)
+{
+ // Constructor
+
+ fNRefFigures = 17;
+
+ for(Int_t k = 0; k < 3; k++)
+ {
+ fNz[k]=0;
+ fNrphi[k]=0;
+ }
+
+}
+
//________________________________________________________________________
AliTRDcalibration::~AliTRDcalibration()
{
}
//________________________________________________________________________
-void AliTRDcalibration::CreateOutputObjects()
+void AliTRDcalibration::UserCreateOutputObjects()
{
// Create output objects
- OpenFile(0, "RECREATE");
+ OpenFile(1, "RECREATE");
// Number of time bins
if(fNbTimeBins==0) {
}
//________________________________________________________________________
-void AliTRDcalibration::Exec(Option_t *)
+void AliTRDcalibration::UserExec(Option_t *)
{
//
// Execute function where the reference data are filled
//printf("Nbof tracks %d\n",nbTrdTracks);
// Post output data
- PostData(0, fContainer);
+ PostData(1, fContainer);
//printf("post container\n");
AliTRDcalibration();
+ AliTRDcalibration(char* name);
virtual ~AliTRDcalibration();
- virtual void CreateOutputObjects();
- virtual void Exec(Option_t *option);
+ virtual void UserCreateOutputObjects();
+ virtual void UserExec(Option_t *option);
virtual void Terminate(Option_t *);
virtual Bool_t GetRefFigure(Int_t ifig);
virtual Bool_t PostProcess();
#include <TProfile.h>
#include <TProfile2D.h>
#include <TROOT.h>
+#include <TChain.h>
#include "AliLog.h"
#include "AliTRDcluster.h"
//_______________________________________________________
AliTRDcheckDET::AliTRDcheckDET():
- AliTRDrecoTask("checkDET", "Basic TRD data checker")
+ AliTRDrecoTask()
,fEventInfo(0x0)
,fTriggerNames(0x0)
,fReconstructor(0x0)
//
// Default constructor
//
- DefineInput(1,AliTRDeventInfo::Class());
+}
+
+
+AliTRDcheckDET::AliTRDcheckDET(char* name):
+ AliTRDrecoTask(name, "Basic TRD data checker")
+ ,fEventInfo(0x0)
+ ,fTriggerNames(0x0)
+ ,fReconstructor(0x0)
+ ,fGeo(0x0)
+ ,fFlags(0)
+{
+ //
+ // Default constructor
+ //
+ DefineInput(2, AliTRDeventInfo::Class());
+
fReconstructor = new AliTRDReconstructor;
fReconstructor->SetRecoParam(AliTRDrecoParam::GetLowFluxParam());
fGeo = new AliTRDgeometry;
InitFunctorList();
}
+
//_______________________________________________________
AliTRDcheckDET::~AliTRDcheckDET(){
//
// Connect the Input data with the task
//
AliTRDrecoTask::ConnectInputData(opt);
- fEventInfo = dynamic_cast<AliTRDeventInfo *>(GetInputData(1));
+ fEventInfo = dynamic_cast<AliTRDeventInfo *>(GetInputData(2));
}
//_______________________________________________________
-void AliTRDcheckDET::CreateOutputObjects(){
+void AliTRDcheckDET::UserCreateOutputObjects(){
//
// Create Output Objects
//
- OpenFile(0,"RECREATE");
+ OpenFile(1,"RECREATE");
fContainer = Histos();
if(!fTriggerNames) fTriggerNames = new TMap();
}
//_______________________________________________________
-void AliTRDcheckDET::Exec(Option_t *opt){
+void AliTRDcheckDET::UserExec(Option_t *opt){
//
// Execution function
// Filling TRD quality histos
if(!fTrackInfo->GetTrack()) continue;
nTracks++;
}
+
if(nTracks){
dynamic_cast<TH1F *>(fContainer->UncheckedAt(kNeventsTriggerTracks))->Fill(triggermask);
dynamic_cast<TH1F *>(fContainer->UncheckedAt(kNtracksEvent))->Fill(nTracks);
histo = dynamic_cast<TH1F *>(fContainer->UncheckedAt(kNeventsTrigger));
histo->GetXaxis()->SetBinLabel(histo->FindBin(triggermask), triggername);
}
- PostData(0, fContainer);
+ PostData(1, fContainer);
}
h->SetBinContent(1, 0.);
// tracklet status
+
TObjArray *arr = dynamic_cast<TObjArray*>(fContainer->UncheckedAt(kTrackletStatus));
for(Int_t ily = AliTRDgeometry::kNlayer; ily--;){
h=dynamic_cast<TH1F*>(arr->At(ily));
//
// Create QA histograms
//
+
if(fContainer) return fContainer;
fContainer = new TObjArray(20);
if(!(h = (TH1F *)gROOT->FindObject("hEventsTrigger")))
h = new TH1F("hEventsTrigger", "Trigger Class", 100, 0, 100);
else h->Reset();
+ printf("Histos Adding \n");
+
fContainer->AddAt(h, kNeventsTrigger);
if(!(h = (TH1F *)gROOT->FindObject("hEventsTriggerTracks")))
};
AliTRDcheckDET();
+ AliTRDcheckDET(char* name);
virtual ~AliTRDcheckDET();
- virtual void ConnectInputData(const Option_t *);
- virtual void CreateOutputObjects();
- virtual void Exec(Option_t *opt);
-
+ virtual void UserCreateOutputObjects();
+ virtual void UserExec(Option_t *opt);
+ virtual void ConnectInputData(Option_t *opt);
virtual TObjArray *Histos();
// Plotting Functions:
//____________________________________________________________________
AliTRDcheckESD::AliTRDcheckESD():
- AliAnalysisTask("checkESD", "ESD checker for TRD info")
+ AliAnalysisTaskSE()
,fStatus(0)
,fESD(NULL)
,fMC(NULL)
// Default constructor
//
SetMC(kTRUE);
- DefineInput(0, TChain::Class());
- DefineOutput(0, TObjArray::Class());
+}
+
+AliTRDcheckESD::AliTRDcheckESD(char* name):
+ AliAnalysisTaskSE(name)
+ ,fStatus(0)
+ ,fESD(NULL)
+ ,fMC(NULL)
+ ,fHistos(NULL)
+ ,fResults(NULL)
+{
+ //
+ // Default constructor
+ //
+ SetMC(kTRUE);
+ DefineOutput(1, TObjArray::Class());
}
//____________________________________________________________________
}
//____________________________________________________________________
-void AliTRDcheckESD::ConnectInputData(Option_t *)
-{
- //
- // Link the Input Data
- //
- TTree *tree = dynamic_cast<TChain*>(GetInputData(0));
- if(tree) tree->SetBranchStatus("Tracks", 1);
-
- AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
- fESD = esdH ? esdH->GetEvent() : NULL;
-
- if(!HasMC()) return;
- AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler*>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
- fMC = mcH ? mcH->MCEvent() : NULL;
-}
-
-//____________________________________________________________________
-void AliTRDcheckESD::CreateOutputObjects()
+void AliTRDcheckESD::UserCreateOutputObjects()
{
//
// Create Output Containers (TObjectArray containing 1D histograms)
}
//____________________________________________________________________
-void AliTRDcheckESD::Exec(Option_t *){
+void AliTRDcheckESD::UserExec(Option_t *){
//
// Run the Analysis
//
+ fESD = dynamic_cast<AliESDEvent*>(InputEvent());
+ fMC = MCEvent();
+
if(!fESD){
AliError("ESD event missing.");
return;
}
-
+
// Get MC information if available
AliStack * fStack = NULL;
if(HasMC()){
}
}
}
- PostData(0, fHistos);
+ PostData(1, fHistos);
}
//____________________________________________________________________
//////////////////////////////////////////////////////
#ifndef ALIANALYSISTASK_H
-#include "AliAnalysisTask.h"
+#include "AliAnalysisTaskSE.h"
#endif
class AliESDEvent;
class TObjArray;
class TGraph;
class TGraphErrors;
-class AliTRDcheckESD : public AliAnalysisTask {
+class AliTRDcheckESD : public AliAnalysisTaskSE {
public:
enum ETRDcheckESDstatus {
kMC = BIT(0) // use MC info
,kTRDref // track refitted in TRD
};
AliTRDcheckESD();
+ AliTRDcheckESD(char* name);
virtual ~AliTRDcheckESD();
- void ConnectInputData(Option_t *);
- void CreateOutputObjects();
+ void UserCreateOutputObjects();
TGraph* GetGraph(Int_t id, Option_t *opt="bc");
- void Exec(Option_t *);
+ void UserExec(Option_t *);
Bool_t HasMC() const { return TESTBIT(fStatus, kMC);}
Bool_t IsLoad() const { return TESTBIT(fStatus, kLoad);}
//________________________________________________________________________
AliTRDcheckPID::AliTRDcheckPID()
- :AliTRDrecoTask("checkPID", "TRD PID checker")
+ :AliTRDrecoTask()
+ ,fReconstructor(NULL)
+ ,fUtil(NULL)
+ ,fGraph(NULL)
+ ,fPID(NULL)
+ ,fMomentumAxis(NULL)
+ ,fMinNTracklets(AliTRDgeometry::kNlayer)
+ ,fMaxNTracklets(AliTRDgeometry::kNlayer)
+ {
+ //
+ // Default constructor
+ //
+}
+
+AliTRDcheckPID::AliTRDcheckPID(char* name )
+ :AliTRDrecoTask(name, "Check PID")
,fReconstructor(NULL)
,fUtil(NULL)
,fGraph(NULL)
fUtil = new AliTRDpidUtil();
InitFunctorList();
- DefineOutput(1, TObjArray::Class()); // PID for reference maker
+
+ DefineOutput(2, TObjArray::Class());
+
}
//________________________________________________________________________
-void AliTRDcheckPID::CreateOutputObjects()
+void AliTRDcheckPID::UserCreateOutputObjects()
{
// Create histograms
// Called once
- OpenFile(0, "RECREATE");
+ OpenFile(1, "RECREATE");
fContainer = Histos();
fPID = new TObjArray();
}
//________________________________________________________
-void AliTRDcheckPID::Exec(Option_t *opt)
+void AliTRDcheckPID::UserExec(Option_t *opt)
{
//
// Execution part
AliTRDrecoTask::Exec(opt);
- PostData(1, fPID);
+ PostData(2, fPID);
}
,kNPlots = 12 // Number of plots for this tasks
};
AliTRDcheckPID();
+ AliTRDcheckPID(char* name);
virtual ~AliTRDcheckPID();
- virtual void CreateOutputObjects();
+ virtual void UserCreateOutputObjects();
virtual Bool_t GetRefFigure(Int_t ifig);
- virtual void Exec(Option_t *opt);
+ virtual void UserExec(Option_t *opt);
virtual Bool_t PostProcess();
TH1 *PlotLQ(const AliTRDtrackV1 *track = 0x0);
const Float_t AliTRDclusterResolution::fgkTimeBinLength = 1./ AliTRDCommonParam::Instance()->GetSamplingFrequency();
//_______________________________________________________
+AliTRDclusterResolution::AliTRDclusterResolution()
+ : AliTRDrecoTask()
+ ,fCanvas(0x0)
+ ,fInfo(0x0)
+ ,fResults(0x0)
+ ,fAt(0x0)
+ ,fStatus(0)
+ ,fDet(-1)
+ ,fExB(0.)
+ ,fVdrift(0.)
+ ,fLy(0)
+ ,fX(0.)
+ ,fY(0.)
+ ,fZ(0.)
+{
+// Constructor
+}
+
AliTRDclusterResolution::AliTRDclusterResolution(const char *name, const char *title)
: AliTRDrecoTask(name, title)
,fCanvas(NULL)
//_______________________________________________________
void AliTRDclusterResolution::ConnectInputData(Option_t *)
{
- fInfo = dynamic_cast<TObjArray *>(GetInputData(0));
+ AliAnalysisTaskSE::ConnectInputData();
+ fInfo = dynamic_cast<TObjArray *>(GetInputData(0));
}
//_______________________________________________________
-void AliTRDclusterResolution::CreateOutputObjects()
+void AliTRDclusterResolution::UserCreateOutputObjects()
{
- OpenFile(0, "RECREATE");
+ OpenFile(1, "RECREATE");
fContainer = Histos();
}
}
//_______________________________________________________
-void AliTRDclusterResolution::Exec(Option_t *)
+void AliTRDclusterResolution::UserExec(Option_t *)
{
// Fill container histograms
// fill histo for systematic (mean)
((TH3S*)arr2->At(ix-1))->Fill(10.*cli->GetAnisochronity(), dydx-cli->GetTilt()*dzdx, dy);
}
- PostData(0, fContainer);
+ PostData(1, fContainer);
}
kSaveAs = BIT(22)
,kExB = BIT(23)
};
- AliTRDclusterResolution(const char *name="ClErrParam", const char *title="Cluster error monitor");
+ AliTRDclusterResolution();
+ AliTRDclusterResolution(const char *name, const char *title="Cluster error monitor");
virtual ~AliTRDclusterResolution();
void ConnectInputData(Option_t *);
- void CreateOutputObjects();
- void Exec(Option_t *);
+ void UserCreateOutputObjects();
+ void UserExec(Option_t *);
Int_t GetDetector() const { return fDet; }
inline Float_t GetExB() const;
inline Float_t GetVdrift() const;
//____________________________________________________________________
AliTRDefficiency::AliTRDefficiency()
- :AliTRDrecoTask("efficiency", "TRD barrel tracking efficiency checker")
+ :AliTRDrecoTask()
+ ,fMissed(0x0)
+{
+ //
+ // Default constructor
+ //
+}
+
+AliTRDefficiency::AliTRDefficiency(char* name)
+ :AliTRDrecoTask(name, "TRD barrel tracking efficiency checker")
,fMissed(0x0)
{
//
}
//____________________________________________________________________
-void AliTRDefficiency::CreateOutputObjects()
+void AliTRDefficiency::UserCreateOutputObjects()
{
//
// Create output objects
//
- OpenFile(0, "RECREATE");
+ OpenFile(1, "RECREATE");
const Int_t nbins = AliTRDCalPID::kNMom;
Float_t xbins[nbins+1] = {.5, .7, .9, 1.3, 1.7, 2.4, 3.5, 4.5, 5.5, 7., 9., 11.};
}
//____________________________________________________________________
-void AliTRDefficiency::Exec(Option_t *)
+void AliTRDefficiency::UserExec(Option_t *)
{
//
// Do it
for(Int_t itk = 0; itk < nTRD - 1; itk++)
if(labelsacc[indices[itk]] ==labelsacc[indices[itk + 1]]) printf("Double counted MC track: %d\n", labelsacc[indices[itk]]);
}
- PostData(0, fContainer);
+ PostData(1, fContainer);
}
{
public:
AliTRDefficiency();
+ AliTRDefficiency(char* name);
virtual ~AliTRDefficiency();
- void CreateOutputObjects();
- void Exec(Option_t *);
+ void UserCreateOutputObjects();
+ void UserExec(Option_t *);
Bool_t GetRefFigure(Int_t ifig);
Bool_t PostProcess();
Float_t AliTRDefficiencyMC::fgThtCut = 50.; //[deg]
//_____________________________________________________________________________
AliTRDefficiencyMC::AliTRDefficiencyMC()
- :AliTRDrecoTask("EfficiencyMC", "Combined Tracking Efficiency")
+ :AliTRDrecoTask()
{
//
// Default constructor
//
}
+AliTRDefficiencyMC::AliTRDefficiencyMC(char* name)
+ :AliTRDrecoTask(name, "Combined Tracking Efficiency")
+{
+ //
+ // Default constructor
+ //
+}
//_____________________________________________________________________________
-void AliTRDefficiencyMC::CreateOutputObjects(){
+void AliTRDefficiencyMC::UserCreateOutputObjects(){
//
// Create output objects
//
- OpenFile(0, "RECREATE");
+ OpenFile(1, "RECREATE");
fContainer = Histos();
}
//_____________________________________________________________________________
-void AliTRDefficiencyMC::Exec(Option_t *){
+void AliTRDefficiencyMC::UserExec(Option_t *){
//
// Execute the task:
//
ncontam,
(nall ? 1.E2*Float_t(ncontam)/Float_t(nall) : 0.)));
- PostData(0, fContainer);
+ PostData(1, fContainer);
}
,kFake
};
AliTRDefficiencyMC();
+ AliTRDefficiencyMC(char* name);
virtual ~AliTRDefficiencyMC(){;}
- void CreateOutputObjects();
- void Exec(Option_t *);
+ void UserCreateOutputObjects();
+ void UserExec(Option_t *);
Bool_t PostProcess();
TObjArray* Histos();
//____________________________________________________________________
AliTRDinfoGen::AliTRDinfoGen():
- AliTRDrecoTask("infoGen", "MC-REC TRD-track list generator")
+ AliTRDrecoTask()
,fEvTrigger("CINT1B-ABCE-NOPF-ALL")
,fESDev(NULL)
,fMCev(NULL)
- ,fESDfriend(NULL)
,fTrackInfo(NULL)
,fEventInfo(NULL)
,fV0container(NULL)
//
// Default constructor
//
+}
- DefineInput(0, TChain::Class());
- DefineOutput(0, TObjArray::Class());
- DefineOutput(1, AliTRDeventInfo::Class());
- DefineOutput(2, TObjArray::Class());
+AliTRDinfoGen::AliTRDinfoGen(char* name):
+ AliTRDrecoTask(name, "MC-REC TRD-track list generator")
+ ,fESDev(NULL)
+ ,fMCev(NULL)
+ ,fTrackInfo(NULL)
+ ,fEventInfo(NULL)
+ ,fV0container(NULL)
+ ,fV0Info(NULL)
+{
+ //
+ // Default constructor
+ //
+ DefineOutput(2, AliTRDeventInfo::Class()); // -> TRDeventInfo
+ DefineOutput(3, TObjArray::Class()); // -> TObjArray
}
//____________________________________________________________________
}
//____________________________________________________________________
-void AliTRDinfoGen::ConnectInputData(Option_t *)
-{
- //
- // Link the Input Data
- //
- TTree *tree = dynamic_cast<TChain*>(GetInputData(0));
- if(!tree){
- AliError("ESD event not found");
- } else {
- tree->SetBranchStatus("Tracks", 1);
- tree->SetBranchStatus("ESDfriend*",1);
- }
-
- AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
- if(!esdH){
- printf("ERROR - ESD input handler not found");
- } else {
- fESDev = esdH->GetEvent();
- if(!fESDev){
- printf("ERROR - ESD event not found");
- } else {
- esdH->SetActiveBranches("ESDfriend*");
- fESDfriend = (AliESDfriend *)fESDev->FindListObject("AliESDfriend");
- }
- }
- if(HasMCdata()){
- AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler*>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
- if(!mcH){
- AliError("MC input handler not found");
- } else {
- fMCev = mcH->MCEvent();
- }
- }
-}
-
-//____________________________________________________________________
-void AliTRDinfoGen::CreateOutputObjects()
+void AliTRDinfoGen::UserCreateOutputObjects()
{
//
// Create Output Containers (TObjectArray containing 1D histograms)
}
//____________________________________________________________________
-void AliTRDinfoGen::Exec(Option_t *){
+void AliTRDinfoGen::UserExec(Option_t *){
//
// Run the Analysis
//
+ fESDev = dynamic_cast<AliESDEvent*>(InputEvent());
+ fMCev = MCEvent();
+
if(!fESDev){
AliError("Failed retrieving ESD event");
return;
AliError("Failed retrieving MC event");
return;
}
+
fContainer->Delete();
fV0container->Delete();
fEventInfo->Delete("");
- fESDev->SetESDfriend(fESDfriend);
new(fEventInfo)AliTRDeventInfo(fESDev->GetHeader(), const_cast<AliESDRun *>(fESDev->GetESDRun()));
Bool_t *trackMap(NULL);
}
delete[] trackMap;
}
- PostData(0, fContainer);
- PostData(1, fEventInfo);
- PostData(2, fV0container);
+ PostData(1, fContainer);
+ PostData(2, fEventInfo);
+ PostData(3, fV0container);
}
,kCollision = BIT(23)
};
AliTRDinfoGen();
+ AliTRDinfoGen(char* name);
virtual ~AliTRDinfoGen();
- void ConnectInputData(Option_t *);
- void CreateOutputObjects();
+
+ void UserCreateOutputObjects();
+ void UserExec(Option_t *);
static Float_t GetTPCx() { return fgkTPC;}
static Float_t GetTOFx() { return fgkTOF;}
AliESDEvent *fESDev; //! ESD event
AliMCEvent *fMCev; //! MC event
- AliESDfriend *fESDfriend; //! ESD friends
AliTRDtrackInfo *fTrackInfo; //! Track info
- AliTRDeventInfo *fEventInfo; //! Event info
+ AliTRDeventInfo *fEventInfo; //! Event info
TObjArray *fV0container; //! V0 container
- AliTRDv0Info *fV0Info; //! V0 info
+ AliTRDv0Info *fV0Info; //! V0 info
- ClassDef(AliTRDinfoGen, 2) // entry to TRD analysis train
+ ClassDef(AliTRDinfoGen, 3) // entry to TRD analysis train
};
#endif
//____________________________________________________________________
AliTRDmultiplicity::AliTRDmultiplicity()
- :AliTRDrecoTask("Multiplicity", "Barrel Tracking Multiplicity")
+ :AliTRDrecoTask()
+ ,fEventCounter(0)
+{
+ //
+ // Default constructor
+ //
+}
+
+AliTRDmultiplicity::AliTRDmultiplicity(char* name)
+ :AliTRDrecoTask(name, "Barrel Tracking Multiplicity")
,fEventCounter(0)
{
//
}
//____________________________________________________________________
-void AliTRDmultiplicity::CreateOutputObjects()
+void AliTRDmultiplicity::UserCreateOutputObjects()
{
//
// Create output objects
//
- OpenFile(0, "RECREATE");
+ OpenFile(1, "RECREATE");
TH1 *h = 0x0;
fContainer = new TObjArray();
}
//____________________________________________________________________
-void AliTRDmultiplicity::Exec(Option_t *)
+void AliTRDmultiplicity::UserExec(Option_t *)
{
//
// Do it
}
- PostData(0, fContainer);
+ PostData(1, fContainer);
}
{
public:
AliTRDmultiplicity();
+ AliTRDmultiplicity(char* name);
virtual ~AliTRDmultiplicity();
- void CreateOutputObjects();
- void Exec(Option_t *);
+ void UserCreateOutputObjects();
+ void UserExec(Option_t *);
private:
AliTRDmultiplicity(const AliTRDmultiplicity&);
}
//________________________________________________________________________
-void AliTRDpidRefMaker::CreateOutputObjects()
+void AliTRDpidRefMaker::UserCreateOutputObjects()
{
// Create histograms
// Called once
- OpenFile(0, "RECREATE");
+ OpenFile(1, "RECREATE");
fContainer = new TObjArray();
fContainer->SetName(Form("Moni%s", GetName()));
}
//________________________________________________________________________
-void AliTRDpidRefMaker::Exec(Option_t *)
+void AliTRDpidRefMaker::UserExec(Option_t *)
{
// Main loop
// Called for each event
Fill();
}
- PostData(0, fContainer);
- PostData(1, fData);
+ PostData(1, fContainer);
+ PostData(2, fData);
}
virtual ~AliTRDpidRefMaker();
void ConnectInputData(Option_t *opt);
- void CreateOutputObjects();
- void Exec(Option_t *option);
+ void UserCreateOutputObjects();
+ void UserExec(Option_t *option);
Float_t GetPthreshold() const { return fPthreshold;}
void SetAbundance(Float_t train);
}
// //________________________________________________________________________
-void AliTRDpidRefMakerLQ::CreateOutputObjects()
+void AliTRDpidRefMakerLQ::UserCreateOutputObjects()
{
// Create histograms
// Called once
//________________________________________________________________________
-void AliTRDpidRefMakerLQ::Exec(Option_t */*opt*/)
+void AliTRDpidRefMakerLQ::UserExec(Option_t */*opt*/)
{
// Load PID data into local data storage
AliTRDpidRefMakerLQ();
~AliTRDpidRefMakerLQ();
- void CreateOutputObjects();
- void Exec(Option_t *opt);
+ void UserCreateOutputObjects();
+ void UserExec(Option_t *opt);
TObject* GetOCDBEntry(Option_t *opt);
Bool_t GetRefFigure(Int_t ifig);
Bool_t HasOnlineMonitor() const {return kTRUE;}
#include "TMethodCall.h"
#include "TMethodArg.h"
#include "TFile.h"
+#include "TChain.h"
#include "TList.h"
#include "TMap.h"
#include "TH1.h"
TList* AliTRDrecoTask::fgTrendPoint(0x0);
TTreeSRedirector* AliTRDrecoTask::fgDebugStream(0x0);
//_______________________________________________________
-AliTRDrecoTask::AliTRDrecoTask(const char *name, const char *title)
- : AliAnalysisTask(name, title)
+
+AliTRDrecoTask::AliTRDrecoTask()
+ : AliAnalysisTaskSE()
+ ,fNRefFigures(0)
+ ,fContainer(0x0)
+ ,fTracks(0x0)
+ ,fkTrack(0x0)
+ ,fkMC(0x0)
+ ,fkESD(0x0)
+ ,fPlotFuncList(0x0)
+{
+}
+
+AliTRDrecoTask::AliTRDrecoTask(const char *name, const char */*title*/)
+ : AliAnalysisTaskSE(name)
,fNRefFigures(0)
,fContainer(0x0)
,fTracks(0x0)
,fkTrack(0x0)
,fkMC(0x0)
,fkESD(0x0)
- ,fDebugLevel(0)
,fPlotFuncList(0x0)
{
- DefineInput(0, TObjArray::Class());
- DefineOutput(0, TObjArray::Class());
+ DefineInput (1, TObjArray::Class());
+ DefineOutput(1, TObjArray::Class());
}
//_______________________________________________________
//
// Connect input data
//
-
- fTracks = dynamic_cast<TObjArray *>(GetInputData(0));
+ AliAnalysisTaskSE::ConnectInputData();
+ fTracks = dynamic_cast<TObjArray *>(GetInputData(1));
}
//_______________________________________________________
-void AliTRDrecoTask::Exec(Option_t *)
+void AliTRDrecoTask::UserExec(Option_t *)
{
// Loop over Plot functors published by particular tasks
plot->Execute(this);
}
}
- PostData(0, fContainer);
+ PostData(1, fContainer);
}
//_______________________________________________________
{
// Generic debug handler
- fDebugLevel = level;
- if(fDebugLevel>=1){
+ fDebug = level;
+ if(fDebug>=1){
TDirectory *savedir = gDirectory;
fgDebugStream = new TTreeSRedirector("TRD.DebugPerformance.root");
savedir->cd();
if(fgDebugStream){
delete fgDebugStream;
fgDebugStream = 0x0;
- fDebugLevel = 0;
+ fDebug = 0;
}
if(HasPostProcess()) PostProcess();
}
//
//////////////////////////////////////////////////
-#ifndef ALIANALYSISTASK_H
-#include "AliAnalysisTask.h"
-#endif
+#include "AliAnalysisTaskSE.h"
#ifndef ALITRDTRACKINFO_H
#include "info/AliTRDtrackInfo.h"
class TTreeSRedirector;
class AliTRDtrackV1;
class AliTRDtrackInfo;
-class AliTRDrecoTask : public AliAnalysisTask
+class AliTRDrecoTask : public AliAnalysisTaskSE
{
public:
enum AliTRDrecoSteeringBits{
,kFriends = BIT(19)
,kPostProcess = BIT(20)
};
+
+ AliTRDrecoTask();
AliTRDrecoTask(const char *name, const char *title);
virtual ~AliTRDrecoTask();
- void ConnectInputData(Option_t *);
- virtual void CreateOutputObjects() = 0;
- virtual void Exec(Option_t *opt);
-
+ virtual void UserCreateOutputObjects() = 0;
+ virtual void UserExec(Option_t *opt);
+ virtual void ConnectInputData(Option_t *);
+ virtual void SetDebugLevel(Int_t level);
+
+
Int_t GetNRefFigures() const { return fNRefFigures; }
TList* GetPlotFunctors() const { return fPlotFuncList;}
virtual Bool_t GetRefFigure(Int_t ifig);
virtual Bool_t Save(TObjArray * const res);
virtual Bool_t PostProcess();
virtual Bool_t PutTrendValue(const Char_t *name, Double_t val);
- virtual void SetDebugLevel(Int_t level);
virtual void SetFriends(Bool_t fr = kTRUE) {SetBit(kFriends, fr);}
virtual void SetMCdata(Bool_t mc = kTRUE) {SetBit(kMCdata, mc);}
virtual void SetPostProcess(Bool_t pp = kTRUE) {SetBit(kPostProcess, pp);}
virtual void Terminate(Option_t *);
protected:
- Int_t DebugLevel() const { return fDebugLevel;}
static TTreeSRedirector* DebugStream() { return fgDebugStream;}
void InitFunctorList();
void Adjust(TF1 *f, TH1 * const h);
,fTrklt(NULL)
,fMCcl(NULL)
,fMCtrklt(NULL)
+{
+ //
+ // Default constructor
+ //
+}
+
+AliTRDresolution::AliTRDresolution(char* name)
+ :AliTRDrecoTask(name, "Spatial and momentum TRD resolution checker")
+ ,fStatus(0)
+ ,fIdxPlot(0)
+ ,fIdxFrame(0)
+ ,fReconstructor(NULL)
+ ,fGeo(NULL)
+ ,fDBPDG(NULL)
+ ,fGraphS(NULL)
+ ,fGraphM(NULL)
+ ,fCl(NULL)
+ ,fTrklt(NULL)
+ ,fMCcl(NULL)
+ ,fMCtrklt(NULL)
{
//
// Default constructor
//________________________________________________________
-void AliTRDresolution::CreateOutputObjects()
+void AliTRDresolution::UserCreateOutputObjects()
{
// spatial resolution
- OpenFile(0, "RECREATE");
+ OpenFile(1, "RECREATE");
fContainer = Histos();
}
//________________________________________________________
-void AliTRDresolution::Exec(Option_t *opt)
+void AliTRDresolution::UserExec(Option_t *opt)
{
//
// Execution part
};
AliTRDresolution();
+ AliTRDresolution(char* name);
virtual ~AliTRDresolution();
- void CreateOutputObjects();
+ void UserCreateOutputObjects();
Bool_t GetRefFigure(Int_t ifig);
TObjArray* Histos();
TObjArray* Results(Int_t i=0) const {return i ? fGraphS : fGraphM;}
- void Exec(Option_t * opt);
+ void UserExec(Option_t * opt);
Bool_t IsVerbose() const {return TESTBIT(fStatus, kVerbose);}
Bool_t IsVisual() const {return TESTBIT(fStatus, kVisual);}
Bool_t PostProcess();
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff