// layer in a given layer (iplane)
//
- const Int_t kMLPscale = 16000; // scaling of the MLP input to be smaller than 1
-
-
if (spec < 0 || spec >= AliPID::kSPECIES) return 0.;
// find the interval in momentum and track segment length which applies for this data
TMultiLayerPerceptron *nn = 0x0;
if(!(nn = (TMultiLayerPerceptron *) fModel->At(GetModelID(imom-1, spec, iplane/*, ilength*/)))){
- //if(!(nn = (TMultiLayerPerceptron*)fModel->At(GetModelID(imom-1, spec, iplane/*, ilength*/)))){
AliInfo(Form("Looking for mom(%f) plane(%d)", mom-1, iplane));
AliError(Form("NN id %d not found in DB.", GetModelID(imom-1, spec, iplane)));
return 0.;
}
Double_t ddedx[AliTRDtrack::kNMLPslice];
+
for (int inode=0; inode<AliTRDtrack::kNMLPslice; inode++) {
- ddedx[inode] = (((Double_t) dedx[inode]/kMLPscale)*3) // Bug fix! Needs new reference data or different calculation of dedx!!!!
+ ddedx[inode] = (((Double_t) dedx[inode]/kMLPscale)*6) // Bug fix! Needs new reference data or different calculation of dedx!!!!
/ (AliTRDcalibDB::Instance()->GetNumberOfTimeBins()/AliTRDtrack::kNMLPslice);
}
+
lNN1 = nn->Evaluate(spec, ddedx);
if(!(nn = (TMultiLayerPerceptron*)fModel->At(GetModelID(imom, spec, iplane/*, ilength*/)))){
- //if(!(nn = (TMultiLayerPerceptron*)fModel->At(GetModelID(imom, spec, iplane/*, ilength*/)))){
AliInfo(Form("Looking for mom(%f) plane(%d)", mom, iplane));
AliError(Form("NN id %d not found in DB.", GetModelID(imom, spec, iplane)));
return lNN1;
class AliTRDCalPIDNN : public AliTRDCalPID
{
-
public:
+ enum{
+ kMLPscale = 16000 // scaling of the MLP input to be smaller than 1
+ };
+
AliTRDCalPIDNN();
AliTRDCalPIDNN(const Text_t *name, const Text_t *title);
virtual ~AliTRDCalPIDNN();
#pragma link C++ class AliTRDtrackInfoGen+;
#pragma link C++ class AliTRDrecoTask+;
#pragma link C++ class AliTRDcheckDetector+;
-#pragma link C++ class AliTRDpidChecker+;
-#pragma link C++ class AliTRDcalibration+;
#pragma link C++ class AliTRDtrackingResolution+;
#pragma link C++ class AliTRDtrackingEfficiency+;
#pragma link C++ class AliTRDtrackingEfficiencyCombined+;
+#pragma link C++ class AliTRDcalibration+;
+#pragma link C++ class AliTRDpidChecker+;
+#pragma link C++ class AliTRDpidRefMaker+;
#endif
qaRec/AliTRDrecoTask.cxx \
qaRec/AliTRDcheckDetector.cxx \
qaRec/AliTRDpidChecker.cxx \
+ qaRec/AliTRDpidRefMaker.cxx \
qaRec/AliTRDcalibration.cxx \
qaRec/AliTRDtrackingResolution.cxx \
qaRec/AliTRDtrackingEfficiency.cxx \
}
//_______________________________________________________
-void AliTRDcheckDetector::GetRefFigure(Int_t ifig, Int_t &first, Int_t &last){
+void AliTRDcheckDetector::GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t */*opt*/){
//
// Setting Reference Figures
//
virtual void Terminate(Option_t *);
virtual Bool_t PostProcess();
- virtual void GetRefFigure(Int_t ifig, Int_t &first, Int_t &last);
+ virtual void GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t *opt);
private:
AliTRDcheckDetector(const AliTRDcheckDetector &);
}
//________________________________________________________
-void AliTRDpidChecker::GetRefFigure(Int_t ifig, Int_t &first, Int_t &last)
+void AliTRDpidChecker::GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t */*opt*/)
{
switch(ifig){
case 0:
{
enum{
- kLQlikelihood = 0 // place for 2-dim LQ electron likelihood distributions
- ,kNNlikelihood = 1 * AliTRDCalPID::kNMom * AliPID::kSPECIES // place for NN electron likelihood distributions
- ,kdEdx = 2 * AliTRDCalPID::kNMom * AliPID::kSPECIES // place for the dE/dx spectra
- ,kPH = 3 * AliTRDCalPID::kNMom * AliPID::kSPECIES // place for pulse height spectra
- ,kMomentum = 4 * AliTRDCalPID::kNMom * AliPID::kSPECIES // place for the momentum distribution
- ,kMomentumBin = kMomentum +1 // place for the momentum distribution
- ,kGraphLQ = kMomentumBin +1 // place for the 2-dim LQ pion efficiencies
- ,kGraphLQerr = kGraphLQ +1 // place for the 2-dim LQ pion efficiency errors
- ,kGraphNN = kGraphLQerr +1 // place for the NN pion efficiencies
- ,kGraphNNerr = kGraphNN +1 // place for the NN pion efficiency errors
+ kLQlikelihood = 0 // place for 2-dim LQ electron likelihood distributions
+ ,kNNlikelihood = 1 * AliTRDCalPID::kNMom * AliPID::kSPECIES // place for NN electron likelihood distributions
+ ,kdEdx = 2 * AliTRDCalPID::kNMom * AliPID::kSPECIES // place for the dE/dx spectra
+ ,kPH = 3 * AliTRDCalPID::kNMom * AliPID::kSPECIES // place for pulse height spectra
+ ,kMomentum = 4 * AliTRDCalPID::kNMom * AliPID::kSPECIES // place for the momentum distribution
+ ,kMomentumBin = kMomentum +1 // place for the momentum distribution
+ ,kGraphLQ = kMomentumBin +1 // place for the 2-dim LQ pion efficiencies
+ ,kGraphLQerr = kGraphLQ +1 // place for the 2-dim LQ pion efficiency errors
+ ,kGraphNN = kGraphLQerr +1 // place for the NN pion efficiencies
+ ,kGraphNNerr = kGraphNN +1 // place for the NN pion efficiency errors
};
enum{
kGraphStart = kGraphLQ
- };
+ };
public:
AliTRDpidChecker();
void CreateOutputObjects();
void Exec(Option_t *option);
- void GetRefFigure(Int_t ifig, Int_t &first, Int_t &last);
+ void GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t *opt);
Bool_t PostProcess();
void Terminate(Option_t *);
--- /dev/null
+#include "TPDGCode.h"
+#include "TH1F.h"
+#include "TTreeStream.h"
+
+#include "AliPID.h"
+#include "AliESDEvent.h"
+#include "AliESDInputHandler.h"
+#include "AliTrackReference.h"
+
+#include "AliAnalysisTask.h"
+
+#include "AliTRDtrackV1.h"
+#include "AliTRDReconstructor.h"
+#include "../Cal/AliTRDCalPID.h"
+#include "../Cal/AliTRDCalPIDNN.h"
+
+#include "AliTRDpidRefMaker.h"
+#include "AliTRDtrackInfo/AliTRDtrackInfo.h"
+
+// builds the reference tree for the training of neural networks
+
+
+ClassImp(AliTRDpidRefMaker)
+
+//________________________________________________________________________
+AliTRDpidRefMaker::AliTRDpidRefMaker()
+ :AliTRDrecoTask("PIDR", "PID Reference Tree Maker")
+ ,fReconstructor(0x0)
+{
+ //
+ // Default constructor
+ //
+
+ fReconstructor = new AliTRDReconstructor();
+ fReconstructor->SetRecoParam(AliTRDrecoParam::GetLowFluxParam());
+}
+
+
+//________________________________________________________________________
+AliTRDpidRefMaker::~AliTRDpidRefMaker()
+{
+ if(fReconstructor) delete fReconstructor;
+}
+
+
+//________________________________________________________________________
+void AliTRDpidRefMaker::CreateOutputObjects()
+{
+ // Create histograms
+ // Called once
+
+ OpenFile(0, "RECREATE");
+ fContainer = new TObjArray();
+
+ fContainer->AddAt(new TH1F("hPDG","hPDG",AliPID::kSPECIES,-0.5,5.5),0);
+}
+
+
+//________________________________________________________________________
+void AliTRDpidRefMaker::Exec(Option_t *)
+{
+ // Main loop
+ // Called for each event
+
+ Int_t labelsacc[10000];
+ memset(labelsacc, 0, sizeof(Int_t) * 10000);
+
+ struct tChamb{
+ Float_t Slide[AliTRDReconstructor::kNNslices];
+ };
+ tChamb Chamb[AliTRDCalPID::kNPlane];
+
+ Float_t *fdEdx;
+
+ Float_t mom;
+ ULong_t status;
+ Int_t nTRD = 0;
+// Float_t fdEdx[AliTRDCalPID::kNPlane][AliTRDReconstructor::kNNslices];
+ Float_t v0pdg[AliPID::kSPECIES];
+
+ AliTRDtrackInfo *track = 0x0;
+ AliTRDtrackV1 *TRDtrack = 0x0;
+ AliTrackReference *ref = 0x0;
+ AliExternalTrackParam *esd = 0x0;
+
+ AliTRDseedV1 *TRDtracklet[AliTRDCalPID::kNPlane];
+ for(Int_t iChamb = 0; iChamb < AliTRDCalPID::kNPlane; iChamb++) TRDtracklet[iChamb] = 0x0;
+
+ //AliTRDcluster *TRDcluster = 0x0;
+
+ for(Int_t itrk=0; itrk<fTracks->GetEntriesFast(); itrk++){
+
+ // reset the pid information
+ for(Int_t iPart = 0; iPart < AliPID::kSPECIES; iPart++)
+ v0pdg[iPart] = 0.;
+
+ track = (AliTRDtrackInfo*)fTracks->UncheckedAt(itrk);
+ if(!track->HasESDtrack()) continue;
+ status = track->GetStatus();
+ if(!(status&AliESDtrack::kTPCout)) continue;
+
+ if(!(TRDtrack = track->GetTRDtrack())) continue;
+ //&&(track->GetNumberOfClustersRefit()
+
+ // use only tracks that hit 6 chambers
+ if(!(TRDtrack->GetNumberOfTracklets() == AliTRDCalPID::kNPlane)) continue;
+
+ ref = track->GetTrackRef(0);
+ esd = track->GetOuterParam();
+ mom = ref ? ref->P(): esd->P();
+
+ labelsacc[nTRD] = track->GetLabel();
+ nTRD++;
+
+ // if no monte carlo data available -> use V0 information
+ if(!HasMCdata()){
+ GetV0info(TRDtrack,v0pdg);
+ }
+ // else use the MC info
+ else{
+ switch(track -> GetPDG()){
+ case kElectron:
+ case kPositron:
+ v0pdg[AliPID::kElectron] = 1.;
+ break;
+ case kMuonPlus:
+ case kMuonMinus:
+ v0pdg[AliPID::kMuon] = 1.;
+ break;
+ case kPiPlus:
+ case kPiMinus:
+ v0pdg[AliPID::kPion] = 1.;
+ break;
+ case kKPlus:
+ case kKMinus:
+ v0pdg[AliPID::kKaon] = 1.;
+ break;
+ case kProton:
+ case kProtonBar:
+ v0pdg[AliPID::kProton] = 1.;
+ break;
+ }
+ }
+
+
+ // set reconstructor
+ TRDtrack -> SetReconstructor(fReconstructor);
+ fReconstructor -> SetOption("nn");
+
+ // fill the dE/dx information
+ for(Int_t iChamb = 0; iChamb < AliTRDCalPID::kNPlane; iChamb++){
+ TRDtracklet[iChamb] = TRDtrack -> GetTracklet(iChamb);
+ fdEdx = TRDtracklet[iChamb] -> GetdEdx();
+ for(Int_t iSlide = 0; iSlide < AliTRDReconstructor::kNNslices; iSlide++)
+ Chamb[iChamb].Slide[iSlide] = fdEdx[iSlide]/AliTRDCalPIDNN::kMLPscale;
+ }
+
+
+ // fill the debug streams
+ if(fDebugLevel>=2){
+ (*fDebugStream) << "TreeInfo"
+ << "isele=" << v0pdg[0]
+ << "ismuo=" << v0pdg[1]
+ << "ispio=" << v0pdg[2]
+ << "iskao=" << v0pdg[3]
+ << "ispro=" << v0pdg[4]
+ << "\n";
+ for(Int_t iChamb = 0; iChamb < AliTRDCalPID::kNPlane; iChamb++){
+ (*fDebugStream) << Form("Chamb%d", iChamb)
+ << "Slide0=" << Chamb[iChamb].Slide[0]
+ << "Slide1=" << Chamb[iChamb].Slide[1]
+ << "Slide2=" << Chamb[iChamb].Slide[2]
+ << "Slide3=" << Chamb[iChamb].Slide[3]
+ << "Slide4=" << Chamb[iChamb].Slide[4]
+ << "Slide5=" << Chamb[iChamb].Slide[5]
+ << "Slide6=" << Chamb[iChamb].Slide[6]
+ << "Slide7=" << Chamb[iChamb].Slide[7]
+ << "\n";
+ }
+ }
+
+ for(Int_t iPart = 0; iPart < AliPID::kSPECIES; iPart++){
+ if(fDebugLevel>=4) Printf("PDG is %d %f", iPart, v0pdg[iPart]);
+ }
+ }
+
+ PostData(0, fContainer);
+}
+
+
+//________________________________________________________
+void AliTRDpidRefMaker::GetRefFigure(Int_t /*ifig*/, Int_t &/*first*/, Int_t &/*last*/, Option_t */*opt*/)
+{
+
+}
+
+
+//________________________________________________________________________
+Bool_t AliTRDpidRefMaker::PostProcess()
+{
+ // Draw result to the screen
+ // Called once at the end of the query
+
+ return kTRUE; // testing protection
+}
+
+
+//________________________________________________________________________
+void AliTRDpidRefMaker::Terminate(Option_t *)
+{
+ // Draw result to the screen
+ // Called once at the end of the query
+
+ fContainer = dynamic_cast<TObjArray*>(GetOutputData(0));
+ if (!fContainer) {
+ Printf("ERROR: list not available");
+ return;
+ }
+}
+
+
+//________________________________________________________________________
+void AliTRDpidRefMaker::GetV0info(AliTRDtrackV1 *TRDtrack, Float_t *v0pdg)
+{
+
+ // !!!! PREMILMINARY FUNCTION !!!!
+ //
+ // this is the place for the V0 procedure
+ // as long as there is no implemented, just the probabilities
+ // of the TRDtrack is used!
+
+ TRDtrack -> SetReconstructor(fReconstructor);
+ fReconstructor -> SetOption("nn");
+ TRDtrack -> CookPID();
+ for(Int_t iPart = 0; iPart < AliPID::kSPECIES; iPart++){
+ v0pdg[iPart] = TRDtrack -> GetPID(iPart);
+ if(fDebugLevel>=4) Printf("PDG is (in V0info) %d %f", iPart, v0pdg[iPart]);
+ }
+}
--- /dev/null
+#ifndef ALITRDPIDREFMAKER_H
+#define ALITRDPIDREFMAKER_H
+
+//////////////////////////////////////////////////////
+//
+// Task to build PID reference tree for the training
+// of neural networs for the TRD PID
+//
+// Author : Alex Wilk <wilka@uni-muenster.de>
+//
+///////////////////////////////////////////////////////
+
+#ifndef ALITRDRECOTASK_H
+#include "AliTRDrecoTask.h"
+#endif
+
+class AliTRDtrackV1;
+class AliTRDReconstructor;
+class AliTRDpidRefMaker : public AliTRDrecoTask
+{
+
+ public:
+ AliTRDpidRefMaker();
+ virtual ~AliTRDpidRefMaker();
+
+ void CreateOutputObjects();
+ void Exec(Option_t *option);
+ void GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t *opt);
+ Bool_t PostProcess();
+ void Terminate(Option_t *);
+
+
+ private:
+ AliTRDpidRefMaker(const AliTRDpidRefMaker&); // not implemented
+ AliTRDpidRefMaker& operator=(const AliTRDpidRefMaker&); // not implemented
+
+ void GetV0info(AliTRDtrackV1 *TRDtrack, Float_t *v0pdg); // get the v0 information
+
+ AliTRDReconstructor *fReconstructor; //! reconstructor needed for recalculation the PID
+
+ ClassDef(AliTRDpidRefMaker, 1); // TRD reference maker for NN
+};
+
+#endif
//_______________________________________________________
-void AliTRDrecoTask::GetRefFigure(Int_t /*ifig*/, Int_t &first, Int_t &last)
+void AliTRDrecoTask::GetRefFigure(Int_t /*ifig*/, Int_t &first, Int_t &last, Option_t */*opt*/)
{
AliWarning("Retrieving reference figures not implemented.");
first = 0; last = 0;
}
//_______________________________________________________
-Bool_t AliTRDrecoTask::Load(Char_t *filename)
+Bool_t AliTRDrecoTask::Load(const Char_t *filename)
{
if(!TFile::Open(filename)) return kFALSE;
TObjArray *o = (TObjArray*)gFile->Get(GetName());
Int_t GetDebugLevel() const { return fDebugLevel;}
Int_t GetNRefFigures() const { return fNRefFigures; }
- virtual void GetRefFigure(Int_t ifig, Int_t &first, Int_t &last);
+ virtual void GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t *opt="lp");
Bool_t HasFriends() const {return TestBit(kFriends);};
Bool_t HasMCdata() const {return TestBit(kMCdata);};
Bool_t HasPostProcess() const {return TestBit(kPostProcess);};
- virtual Bool_t Load(Char_t *filename);
+ virtual Bool_t Load(const Char_t *filename);
virtual Bool_t PostProcess();
virtual void SetDebugLevel(Int_t level);
virtual void SetFriends(Bool_t fr = kTRUE) {SetBit(kFriends, fr);}
h = new TH1I("h", "", 100, -40., 40.);
h->GetXaxis()->SetTitle("#Phi [deg]");
h->GetYaxis()->SetTitle("Tracklet Angular Resolution : #sigma/#mu [deg]");
- h->GetYaxis()->SetRangeUser(-.05, 1.);
+ h->GetYaxis()->SetRangeUser(-.05, .2);
fContainer->AddAt(h, jgraph++);
g = new TGraphErrors(h2->GetNbinsX());
}
//________________________________________________________
-void AliTRDtrackingResolution::GetRefFigure(Int_t ifig, Int_t &first, Int_t &last)
+void AliTRDtrackingResolution::GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t */*opt*/)
{
switch(ifig){
case 0:
void CreateOutputObjects();
void Exec(Option_t *);
- void GetRefFigure(Int_t ifig, Int_t &first, Int_t &last);
+ void GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t *opt);
void SetRecoParam(AliTRDrecoParam *r);
Bool_t PostProcess();
void Terminate(Option_t *);
#if ! defined (__CINT__) || defined (__MAKECINT__)
+#include "TError.h"
#include <TClass.h>
#include <TFileMerger.h>
-#include <TPad.h>
+#include <TCanvas.h>
#include <TH1.h>
#include <TGraph.h>
#include <TObjArray.h>
#include <TString.h>
#include <TROOT.h>
#include <TSystem.h>
+#include <TStyle.h>
#include "qaRec/AliTRDrecoTask.h"
-// #include <string>
-// #include <iostream>
-// #include <cstdio>
-
#endif
#include "run.h"
void makeResults(Char_t* dir=0x0, Char_t *tasks = "ALL")
{
// Load Libraries in interactive mode
-//#ifndef __CINT__
Int_t nlibs = static_cast<Int_t>(sizeof(libs)/sizeof(Char_t *));
for(Int_t ilib=0; ilib<nlibs; ilib++){
if(!gSystem->Load(libs[ilib])) continue;
printf("Failed to load %s.\n", libs[ilib]);
return;
}
- //gSystem->Setenv("PYTHONPATH", "$ROOTSYS/lib:$PYTHONPATH");
-//#endif
- //printf("dir[%s] tasks[%s]\n", dir, tasks);
gStyle->SetOptStat(0);
Bool_t mc = kTRUE;
Bool_t friends = kTRUE;
if(s.CompareTo("ALL") == 0){
for(Int_t itask = 1; itask < fknTasks; itask++) SETBIT(fSteerTask, itask);
continue;
- } else if(s.CompareTo("EFF") == 0){
- SETBIT(fSteerTask, kTrackingEfficiency);
- continue;
- } else if(s.CompareTo("EFFC") == 0){
- SETBIT(fSteerTask, kTrackingCombinedEfficiency);
- continue;
- } else if(s.CompareTo("RES") == 0){
- SETBIT(fSteerTask, kTrackingResolution);
- continue;
- } else if(s.CompareTo("CAL" ) == 0){
- SETBIT(fSteerTask, kCalibration);
- continue;
- } else if(s.CompareTo("PID" ) == 0){
- SETBIT(fSteerTask, kPIDChecker);
- continue;
- } else if(s.CompareTo("DET" ) == 0){
- SETBIT(fSteerTask, kCheckDetector);
- continue;
- } else{
- std::cout << "E-makeResults.C: Task "<< s.Data() << " %s not implemented (yet).\n";
- continue;
+ } else if(s.CompareTo("NOFR") == 0){
+ friends = kFALSE;
+ } else if(s.CompareTo("NOMC") == 0){
+ mc = kFALSE;
+ } else {
+ Bool_t foundOpt = kFALSE;
+ for(Int_t itask = 1; itask < fknTasks; itask++){
+ if(s.CompareTo(fTaskOpt[itask]) != 0) continue;
+ SETBIT(fSteerTask, itask);
+ foundOpt = kTRUE;
+ break;
+ }
+ if(!foundOpt) Info("makeResults.C", Form("Task %s not implemented (yet).", s.Data()));
}
}
+
// catch the list of files using the ROOT Python Interface
TPython *pyshell = new TPython();
pyshell->Exec("import commands");
ctask = new TClass(fTaskClass[itask]);
task = (AliTRDrecoTask*)ctask->New();
- task->SetDebugLevel(2);
+ task->SetDebugLevel(0);
task->SetMCdata(mc);
task->SetFriends(friends);
printf("\t%s [%s]\n", task->GetTitle(), task->GetName());
task->PostProcess();
for(Int_t ipic=0; ipic<task->GetNRefFigures(); ipic++){
TCanvas *c = new TCanvas("c", "", 500, 500);
- Int_t ifirst, ilast;
+ Int_t ifirst, ilast; Option_t *opt;
TH1 *h = 0x0; TGraph *g = 0x0;
- task->GetRefFigure(ipic, ifirst, ilast);
+ task->GetRefFigure(ipic, ifirst, ilast, opt);
if(!(o = fContainer->At(ifirst))) continue;
if(o->InheritsFrom("TH1")){
// "PID" : TRD PID - pion efficiency
// "PIDR" : TRD PID - reference data
// "DET" : Basic TRD Detector checks
+// "NOFR" : Data set does not have AliESDfriends.root
// "NOMC" : Data set does not have Monte Carlo Informations (real data), so all tasks which rely
// on MC information are switched off
//
#include "TRD/qaRec/AliTRDtrackingResolution.h"
#include "TRD/qaRec/AliTRDcalibration.h"
#include "TRD/qaRec/AliTRDpidChecker.h"
+#include "TRD/qaRec/AliTRDpidRefMaker.h"
#include "TRD/qaRec/AliTRDcheckDetector.h"
#endif
gSystem->Load("libANALYSIS.so");
gSystem->Load("libTRDqaRec.so");
- Int_t fSteerTask = 0;
Bool_t fHasMCdata = kTRUE;
+ Bool_t fHasFriends = kTRUE;
TObjArray *tasksArray = TString(tasks).Tokenize(" ");
+
+ Int_t fSteerTask = 0; SETBIT(fSteerTask, kInfoGen);
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 < fknTasks; itask++) SETBIT(fSteerTask, itask);
- continue;
- } else if(s.CompareTo("EFF") == 0){
- SETBIT(fSteerTask, kTrackingEfficiency);
- continue;
- } else if(s.CompareTo("EFFC") == 0){
- SETBIT(fSteerTask, kTrackingCombinedEfficiency);
- continue;
- } else if(s.CompareTo("RES") == 0){
- SETBIT(fSteerTask, kTrackingResolution);
+ for(Int_t itask = 1; itask < fknTasks; itask++) SETBIT(fSteerTask, itask);
continue;
- } else if(s.CompareTo("CAL" ) == 0){
- SETBIT(fSteerTask, kCalibration);
- continue;
- } else if(s.CompareTo("PID" ) == 0){
- SETBIT(fSteerTask, kPIDChecker);
- continue;
- } else if(s.CompareTo("DET" ) == 0){
- SETBIT(fSteerTask, kCheckDetector);
- continue;
- } else if(s.CompareTo("NOMC") == 0){
- CLEARBIT(fSteerTask, kTrackingEfficiency);
- CLEARBIT(fSteerTask, kTrackingCombinedEfficiency);
+ } else if(s.CompareTo("NOFR") == 0){
+ fHasFriends = kFALSE;
+ } else if(s.CompareTo("NOMC") == 0){
fHasMCdata = kFALSE;
- } else{
- Info("run.C", Form("Task %s not implemented (yet).", s.Data()));
- continue;
+ } else {
+ Bool_t foundOpt = kFALSE;
+ for(Int_t itask = 1; itask < fknTasks; itask++){
+ if(s.CompareTo(fTaskOpt[itask]) != 0) continue;
+ SETBIT(fSteerTask, itask);
+ foundOpt = kTRUE;
+ break;
+ }
+ if(!foundOpt) Info("run.C", Form("Task %s not implemented (yet).", s.Data()));
}
}
-
// define task list pointers;
AliTRDrecoTask *taskPtr[fknTasks], *task = 0x0;
memset(taskPtr, 0, fknTasks*sizeof(AliAnalysisTask*));
mgr->ConnectInput( task, 0, cinput1);
mgr->ConnectOutput(task, 0, coutput1);
+ //____________________________________________
+ // TRD detector checker
+ if(TESTBIT(fSteerTask, kCheckDetector)){
+ mgr->AddTask(task = new AliTRDcheckDetector());
+ taskPtr[(Int_t)kCheckDetector] = 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())));
+ }
+
//____________________________________________
// TRD barrel tracking efficiency
- if(TESTBIT(fSteerTask, kTrackingEfficiency)){
+ if(fHasMCdata && TESTBIT(fSteerTask, kTrackingEfficiency)){
mgr->AddTask(task = new AliTRDtrackingEfficiency());
taskPtr[(Int_t)kTrackingEfficiency] = task;
task->SetDebugLevel(0);
//Create containers for input/output
- AliAnalysisDataContainer *coutput2 = mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName()));
mgr->ConnectInput( task, 0, coutput1);
- mgr->ConnectOutput(task, 0, coutput2);
+ mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
}
//____________________________________________
// TRD combined tracking efficiency
- if(TESTBIT(fSteerTask, kTrackingCombinedEfficiency)){
+ if(fHasMCdata && TESTBIT(fSteerTask, kTrackingCombinedEfficiency)){
mgr->AddTask(task = new AliTRDtrackingEfficiencyCombined());
taskPtr[(Int_t)kTrackingCombinedEfficiency] = task;
task->SetDebugLevel(0);
// Create containers for input/output
- AliAnalysisDataContainer *coutput3 = mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName()));
mgr->ConnectInput( task, 0, coutput1);
- mgr->ConnectOutput(task, 0, coutput3);
+ mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
}
//____________________________________________
task->SetDebugLevel(2);
// Create containers for input/output
- AliAnalysisDataContainer *coutput4 = mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName()));
mgr->ConnectInput( task, 0, coutput1);
- mgr->ConnectOutput(task, 0, coutput4);
+ mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
}
//____________________________________________
task->SetDebugLevel(0);
// Create containers for input/output
- AliAnalysisDataContainer *coutput5 = mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName()));
mgr->ConnectInput(task, 0, coutput1);
- mgr->ConnectOutput(task, 0, coutput5);
+ mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
}
//____________________________________________
task->SetMCdata(fHasMCdata);
// Create containers for input/output
- AliAnalysisDataContainer *coutput6 = mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName()));
mgr->ConnectInput( task, 0, coutput1);
- mgr->ConnectOutput(task, 0, coutput6);
+ mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
}
+
//____________________________________________
- // TRD detector checker
- if(TESTBIT(fSteerTask, kCheckDetector)){
- mgr->AddTask(task = new AliTRDcheckDetector());
- taskPtr[(Int_t)kCheckDetector] = task;
+ // TRD pid checker
+ if(TESTBIT(fSteerTask, kPIDRefMaker)){
+ mgr->AddTask(task = new AliTRDpidRefMaker());
+ taskPtr[(Int_t)kPIDRefMaker] = task;
task->SetDebugLevel(0);
task->SetMCdata(fHasMCdata);
// Create containers for input/output
- AliAnalysisDataContainer *coutput7 = mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName()));
mgr->ConnectInput( task, 0, coutput1);
- mgr->ConnectOutput(task, 0, coutput7);
+ mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
}
+
if (!mgr->InitAnalysis()) return;
printf("\n\tRUNNING TRAIN FOR TASKS:\n");
for(Int_t itask = 1; itask < fknTasks; itask++){
#define TESTBIT(n,i) ((Bool_t)(((n) & BIT(i)) != 0))
#define CLEARBIT(n,i) ((n) &= ~BIT(i))
-const Int_t fknTasks = 7;
+const Int_t fknTasks = 8;
enum AliTRDrecoTasks{
- kInfoGen = 0
- ,kTrackingEfficiency = 1
- ,kTrackingCombinedEfficiency = 2
- ,kTrackingResolution = 3
- ,kCalibration = 4
- ,kPIDChecker = 5
- ,kCheckDetector = 6
+ kInfoGen = 0
+ ,kCheckDetector = 1
+ ,kTrackingEfficiency = 2
+ ,kTrackingCombinedEfficiency = 3
+ ,kTrackingResolution = 4
+ ,kCalibration = 5
+ ,kPIDChecker = 6
+ ,kPIDRefMaker = 7
};
Char_t *fTaskClass[fknTasks] = {
"AliTRDtrackInfoGen"
+ ,"AliTRDcheckDetector"
,"AliTRDtrackingEfficiency"
,"AliTRDtrackingEfficiencyCombined"
,"AliTRDtrackingResolution"
,"AliTRDcalibration"
,"AliTRDpidChecker"
- ,"AliTRDcheckDetector"
+ ,"AliTRDpidRefMaker"
+};
+
+Char_t *fTaskOpt[fknTasks+2] = {
+ "ALL"
+ ,"DET"
+ ,"EFF"
+ ,"EFFC"
+ ,"RES"
+ ,"CAL"
+ ,"PID"
+ ,"PIDR"
+ ,"NOFR"
+ ,"NOMC"
};
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff