// Gines Martinez, Subatech, September 2003
//
-
//Root includes
#include "TNamed.h"
//AliRoot include
#include "AliMUONGlobalTrigger.h"
#include "AliMUONRawCluster.h"
#include "AliMUONTrack.h"
-
+#include "AliMUONTriggerTrack.h"
ClassImp(AliMUONData)
//_____________________________________________________________________________
fGlobalTrigger = 0x0; //! List of Global Trigger 1st event in TreeR/GlobalTriggerBranch
fLocalTrigger = 0x0; //! List of Local Trigger, 1st event in TreeR/LocalTriggerBranch
fRecTracks = 0x0;
+ fRecTriggerTracks = 0x0;
fSplitLevel = 0;
//default constructor
}
fGlobalTrigger = 0x0; //! List of Global Trigger 1st event in TreeR/GlobalTriggerBranch
fLocalTrigger = 0x0; //! List of Local Trigger, 1st event in TreeR/LocalTriggerBranch
fRecTracks = 0x0;
+ fRecTriggerTracks = 0x0;
fNhits = 0;
fNglobaltrigger =0;
fNlocaltrigger = 0;
fNrectracks = 0;
+ fNrectriggertracks = 0;
fSplitLevel = 0;
// fHits = new TClonesArray("AliMUONHit",1000);
// fNhits = 0;
fRecTracks->Delete();
delete fRecTracks;
}
+ if (fRecTriggerTracks){
+ fRecTriggerTracks->Delete();
+ delete fRecTriggerTracks;
+ }
//detructor
}
//_____________________________________________________________________________
new(lrectracks[fNrectracks++]) AliMUONTrack(track);
// printf("TTTTTT %d ,\n",((AliMUONTrack*)fRecTracks->At(fNrectracks-1))->GetNTrackHits());
}
+//_____________________________________________________________________________
+void AliMUONData::AddRecTriggerTrack(const AliMUONTriggerTrack& triggertrack)
+{
+ //
+ // Add a MUON triggerrectrack
+ //
+ TClonesArray &lrectriggertracks = *fRecTriggerTracks;
+ new(lrectriggertracks[fNrectriggertracks++]) AliMUONTriggerTrack(triggertrack);
+ // printf("TTTTTT %d ,\n",((AliMUONTrack*)fRecTracks->At(fNrectracks-1))->GetNTrackHits());
+}
+
//____________________________________________________________________________
TClonesArray* AliMUONData::Digits(Int_t DetectionPlane)
{
}
}
//____________________________________________________________________________
+Bool_t AliMUONData::IsTrackBranchesInTree()
+{
+ // Checking if there are Track Branches In TreeT
+ if (TreeT()==0x0) {
+ Error("TreeT","No treeT in memory");
+ return kFALSE;
+ }
+ else {
+ char branchname[30];
+ sprintf(branchname,"%sTrack",GetName());
+ TBranch * branch = 0x0;
+ branch = TreeT()->GetBranch(branchname);
+ if (branch) return kTRUE;
+ else return kFALSE;
+ }
+}
+//____________________________________________________________________________
+Bool_t AliMUONData::IsTriggerTrackBranchesInTree()
+{
+ // Checking if there are TriggerTrack Branches In TreeT
+ if (TreeT()==0x0) {
+ Error("TreeT","No treeT in memory");
+ return kFALSE;
+ }
+ else {
+ char branchname[30];
+ sprintf(branchname,"%sTriggerTrack",GetName());
+ TBranch * branch = 0x0;
+ branch = TreeT()->GetBranch(branchname);
+ if (branch) return kTRUE;
+ else return kFALSE;
+ }
+}
+//____________________________________________________________________________
void AliMUONData::Fill(Option_t* option)
{
// Method to fill the trees
const char *cRC = strstr(option,"RC"); // RawCluster branches in TreeR
const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeR
const char *cRT = strstr(option,"RT"); // Reconstructed Track in TreeT
+ const char *cRL = strstr(option,"RL"); // Reconstructed Trigger Track in TreeT
//const char *cRP = strstr(option,"RP"); // Reconstructed Particle in TreeP
//
// filling tracks
if ( TreeT() && cRT ) {
- sprintf(branchname,"%sTrack",GetName());
- TreeT()->Fill();
+ if (IsTriggerTrackBranchesInTree()) {
+ sprintf(branchname,"%sTrack",GetName());
+ branch = TreeT()->GetBranch(branchname);
+ branch->Fill();
+ }
+ else TreeT()->Fill();
+ }
+ // filling trigger tracks
+ if ( TreeT() && cRL ) {
+ if (IsTrackBranchesInTree()) {
+ sprintf(branchname,"%sTriggerTrack",GetName());
+ branch = TreeT()->GetBranch(branchname);
+ branch->Fill();
+ }
+ else TreeT()->Fill();
}
-// if ( TreeT() && cRTT ) {
+// if ( TreeT() && cRL ) {
// sprintf(branchname,"%sTrackTrig",GetName());
// TreeT()->Fill();
// }
const Int_t kBufferSize = 4000;
char branchname[30];
+
const char *cH = strstr(option,"H");
const char *cD = strstr(option,"D"); // Digits branches in TreeD
const char *cRC = strstr(option,"RC"); // RawCluster branches in TreeR
const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeR
const char *cRT = strstr(option,"RT"); // Reconstructed Track in TreeT
+ const char *cRL = strstr(option,"RL"); // Reconstructed Trigger Track in TreeT
//const char *cRP = strstr(option,"RP"); // Reconstructed Particle in TreeP
-
+
TBranch * branch = 0x0;
// Creating Branches for Hits
branch = TreeT()->Branch(branchname,&fRecTracks,kBufferSize);
Info("MakeBranch","Making Branch %s for tracks \n",branchname);
}
+// trigger tracks
+ if (TreeT() && cRL ) {
+ if (fRecTriggerTracks == 0x0) fRecTriggerTracks = new TClonesArray("AliMUONTriggerTrack",100);
+ fNrectriggertracks = 0;
+ sprintf(branchname,"%sTriggerTrack",GetName());
+ branch = TreeT()->GetBranch(branchname);
+ if (branch) {
+ Info("MakeBranch","Branch %s is already in tree.",GetName());
+ return ;
+ }
+ branch = TreeT()->Branch(branchname,&fRecTriggerTracks,kBufferSize);
+ Info("MakeBranch","Making Branch %s for trigger tracks \n",branchname);
+ }
}
//____________________________________________________________________________
TClonesArray* AliMUONData::RawClusters(Int_t DetectionPlane)
return NULL;
}
//____________________________________________________________________________
+TClonesArray* AliMUONData::LocalTrigger()
+{
+ // Getting Local Trigger
+ if (fLocalTrigger)
+ return ( (TClonesArray*) fLocalTrigger );
+ else
+ return NULL;
+}
+//____________________________________________________________________________
+TClonesArray* AliMUONData::GlobalTrigger()
+{
+ // Getting Global Trigger
+ if (fGlobalTrigger)
+ return ( (TClonesArray*) fGlobalTrigger );
+ else
+ return NULL;
+}
+//____________________________________________________________________________
void AliMUONData::ResetDigits()
{
//
fNrectracks = 0;
if (fRecTracks) fRecTracks->Clear();
}
+//____________________________________________________________________________
+void AliMUONData::ResetRecTriggerTracks()
+{
+ // Reset tracks information
+ fNrectriggertracks = 0;
+ if (fRecTriggerTracks) fRecTriggerTracks->Clear();
+}
//_____________________________________________________________________________
void AliMUONData::SetTreeAddress(Option_t* option)
{
const char *cRC = strstr(option,"RC"); // RawCluster branches in TreeR
const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeR
const char *cRT = strstr(option,"RT"); // Reconstructed Track in TreeT
+ const char *cRL = strstr(option,"RL"); // Reconstructed Trigger Track in TreeT
//const char *cRP = strstr(option,"RP"); // Reconstructed Particle in TreeP
// Set branch address for the Hits, Digits, RawClusters, GlobalTrigger and LocalTrigger Tree.
if (branch) branch->SetAddress(&fRecTracks);
else Warning("SetTreeAddress","(%s) Failed for Tracks. Can not find branch in tree.",GetName());
}
+// trigger tracks
+ if ( TreeT() ) {
+ if (fRecTriggerTracks == 0x0 && cRL) {
+ fRecTriggerTracks = new TClonesArray("AliMUONTriggerTrack",100);
+ }
+
+ }
+ if ( TreeT() && fRecTriggerTracks && cRL ) {
+ sprintf(branchname,"%sTriggerTrack",GetName());
+ branch = TreeT()->GetBranch(branchname);
+ if (branch) branch->SetAddress(&fRecTriggerTracks);
+ else Warning("SetTreeAddress","(%s) Failed for Trigger Tracks. Can not find branch in tree.",GetName());
+ }
+
}
//_____________________________________________________________________________
class AliMUONConstants;
class AliMUONRawCluster;
class AliMUONTrack;
+class AliMUONTriggerTrack;
class AliMUONDigit;
class AliMUONHit;
class AliMUONLocalTrigger;
virtual void AddRawCluster(Int_t id, const AliMUONRawCluster& clust);
virtual void AddRecTrack(const AliMUONTrack& track);
+ virtual void AddRecTriggerTrack(const AliMUONTriggerTrack& triggertrack);
TClonesArray* Hits() {return fHits;}
TClonesArray* Digits(Int_t DetectionPlane);
- TClonesArray* LocalTrigger() {return fLocalTrigger;}
- TClonesArray* GlobalTrigger() {return fGlobalTrigger;}
+// TClonesArray* LocalTrigger() {return fLocalTrigger;}
+// TClonesArray* GlobalTrigger() {return fGlobalTrigger;}
+ TClonesArray* LocalTrigger();
+ TClonesArray* GlobalTrigger();
TClonesArray* RawClusters(Int_t DetectionPlane);
TClonesArray* RecTracks() {return fRecTracks;}
+ TClonesArray* RecTriggerTracks() {return fRecTriggerTracks;}
void GetTrack(Int_t it) {fLoader->TreeH()->GetEvent(it);}
Int_t GetNtracks() {return (Int_t) fLoader->TreeH()->GetEntries();}
void GetTrigger() {fLoader->TreeR()->GetEvent(0);}
Int_t GetSplitLevel() {return fSplitLevel;}
void GetRecTracks() {fLoader->TreeT()->GetEvent(0);}
+ void GetRecTriggerTracks() {fLoader->TreeT()->GetEvent(0);}
Bool_t IsRawClusterBranchesInTree();
Bool_t IsTriggerBranchesInTree();
+ Bool_t IsTrackBranchesInTree();
+ Bool_t IsTriggerTrackBranchesInTree();
virtual AliLoader* GetLoader() {return fLoader;}
virtual void SetLoader(AliLoader * loader) {fLoader=loader;}
virtual void ResetTrigger();
virtual void ResetRawClusters();
virtual void ResetRecTracks();
+ virtual void ResetRecTriggerTracks();
TTree* TreeH() {return fLoader->TreeH(); }
TTree* TreeD() {return fLoader->TreeD(); }
TClonesArray* fGlobalTrigger; // List of Global Trigger One event in TreeR/GlobalTriggerBranch
TClonesArray* fLocalTrigger; // List of Local Trigger, One event in TreeR/LocalTriggerBranch
TClonesArray* fRecTracks; // pointer to array of reconstructed tracks
+ TClonesArray* fRecTriggerTracks; // pointer to array of reconstructed trigger tracks
Int_t fNhits; //! Number of Hits
Int_t* fNdigits;//! Number of Digits
Int_t fNglobaltrigger;//! Number of Global trigger
Int_t fNlocaltrigger;//! Number of Local trigger
Int_t fNrectracks; //! Number of reconstructed tracks
+ Int_t fNrectriggertracks; //! Number of reconstructed tracks
Int_t fSplitLevel; // Splitting of branches 0 no spitting (root files are smaller) 1 splitting (larger output files)
ClassDef(AliMUONData,1)
#include "AliMUONChamber.h"
#include "AliMUONEventReconstructor.h"
#include "AliMUONHitForRec.h"
+#include "AliMUONTriggerTrack.h"
+//#include "AliMUONTriggerConstants.h"
+#include "AliMUONTriggerCircuit.h"
#include "AliMUONRawCluster.h"
+#include "AliMUONLocalTrigger.h"
#include "AliMUONRecoEvent.h"
#include "AliMUONSegment.h"
#include "AliMUONTrack.h"
// Is 10 the right size ????
fRecTracksPtr = new TClonesArray("AliMUONTrack", 10);
fNRecTracks = 0; // really needed or GetEntriesFast sufficient ????
+// trigger tracks
+ fRecTriggerTracksPtr = new TClonesArray("AliMUONTriggerTrack", 10);
+ fNRecTriggerTracks = 0; // really needed or GetEntriesFast sufficient ????
// Memory allocation for the TClonesArray of hits on reconstructed tracks
// Is 100 the right size ????
fRecTrackHitsPtr = new TClonesArray("AliMUONTrack", 100);
return;
}
+//__________________________________________________________________________
+void AliMUONEventReconstructor::EventReconstructTrigger(void)
+{
+ // To reconstruct one event
+ if (fPrintLevel >= 1) cout << "enter EventReconstructTrigger" << endl;
+ MakeTriggerTracks();
+ return;
+}
+
//__________________________________________________________________________
void AliMUONEventReconstructor::ResetHitsForRec(void)
{
return;
}
+ //__________________________________________________________________________
+void AliMUONEventReconstructor::ResetTriggerTracks(void)
+{
+ // To reset the TClonesArray of reconstructed trigger tracks
+ if (fRecTriggerTracksPtr) fRecTriggerTracksPtr->Delete();
+ // Delete in order that the Track destructors are called,
+ // hence the space for the TClonesArray of pointers to TrackHit's is freed
+ fNRecTriggerTracks = 0;
+ return;
+}
+
//__________________________________________________________________________
void AliMUONEventReconstructor::ResetTrackHits(void)
{
return;
}
+ //__________________________________________________________________________
+void AliMUONEventReconstructor::MakeTriggerTracks(void)
+{
+ // To make the trigger tracks from Local Trigger
+ if (fPrintLevel >= 1) cout << "enter MakeTriggerTracks" << endl;
+ ResetTriggerTracks();
+
+ Int_t nTRentries;
+ TClonesArray *localTrigger;
+ AliMUONLocalTrigger *locTrg;
+ AliMUONTriggerCircuit *circuit;
+ AliMUONTriggerTrack *recTriggerTrack;
+
+ TString evfoldname = AliConfig::fgkDefaultEventFolderName;//to be interfaced properly
+ AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
+ if (rl == 0x0)
+ {
+ Error("MakeTriggerTracks",
+ "Can not find Run Loader in Event Folder named %s.",
+ evfoldname.Data());
+ return;
+ }
+ AliLoader* gime = rl->GetLoader("MUONLoader");
+ if (gime == 0x0)
+ {
+ Error("MakeTriggerTracks","Can not get MUON Loader from Run Loader.");
+ return;
+ }
+ TTree* TR = gime->TreeR();
+
+ // Loading AliRun master
+ rl->LoadgAlice();
+ gAlice = rl->GetAliRun();
+
+ // Loading MUON subsystem
+ AliMUON * pMUON = (AliMUON *) gAlice->GetDetector("MUON");
+
+ nTRentries = Int_t(TR->GetEntries());
+ if (nTRentries != 1) {
+ cout << "Error in AliMUONEventReconstructor::MakeTriggerTracks"
+ << endl;
+ cout << "nTRentries = " << nTRentries << " not equal to 1" << endl;
+ exit(0);
+ }
+ gime->TreeR()->GetEvent(0); // only one entry
+
+ pMUON->GetMUONData()->SetTreeAddress("GLT");
+ pMUON->GetMUONData()->GetTrigger();
+
+ localTrigger = pMUON->GetMUONData()->LocalTrigger();
+ Int_t nlocals = (Int_t) (localTrigger->GetEntries());
+ Float_t z11 = ( &(pMUON->Chamber(10)) )->Z();
+ Float_t z21 = ( &(pMUON->Chamber(12)) )->Z();
+
+ for (Int_t i=0; i<nlocals; i++) { // loop on Local Trigger
+ locTrg = (AliMUONLocalTrigger*)localTrigger->UncheckedAt(i);
+ circuit = &(pMUON->TriggerCircuit(locTrg->LoCircuit()));
+ Float_t y11 = circuit->GetY11Pos(locTrg->LoStripX());
+ Float_t y21 = circuit->GetY21Pos(locTrg->LoStripX());
+ Float_t x11 = circuit->GetX11Pos(locTrg->LoStripY());
+ Float_t thetax = TMath::ATan2( x11 , z11 );
+ Float_t thetay = TMath::ATan2( (y21-y11) , (z21-z11) );
+
+ recTriggerTrack = new ((*fRecTriggerTracksPtr)[fNRecTriggerTracks])
+ AliMUONTriggerTrack(x11,y11,thetax,thetay,this);
+ fNRecTriggerTracks++;
+ } // end of loop on Local Trigger
+ return;
+}
+
//__________________________________________________________________________
Int_t AliMUONEventReconstructor::MakeTrackCandidatesWithTwoSegments(AliMUONSegment *BegSegment)
{
return;
}
+
+//__________________________________________________________________________
+void AliMUONEventReconstructor::EventDumpTrigger(void)
+{
+ // Dump reconstructed trigger event
+ // and the particle parameters
+
+ AliMUONTriggerTrack *triggertrack;
+ Int_t trackIndex;
+
+ if (fPrintLevel >= 1) cout << "****** enter EventDumpTrigger ******" << endl;
+ if (fPrintLevel >= 1) {
+ cout << " Number of Reconstructed tracks :" << fNRecTriggerTracks << endl;
+ }
+ // Loop over reconstructed tracks
+ for (trackIndex = 0; trackIndex < fNRecTriggerTracks; trackIndex++) {
+ triggertrack = (AliMUONTriggerTrack*) ((*fRecTriggerTracksPtr)[trackIndex]);
+ printf(" trigger track number %i x11=%f y11=%f thetax=%f thetay=%f \n",
+ trackIndex,
+ triggertrack->GetX11(),triggertrack->GetY11(),
+ triggertrack->GetThetax(),triggertrack->GetThetay());
+ }
+}
+
+//__________________________________________________________________________
void AliMUONEventReconstructor::FillEvent()
{
// Create a new AliMUONRecoEvent, fill its track list, then add it as a
void SetNRecTracks(Int_t NRecTracks) {fNRecTracks = NRecTracks;}
TClonesArray* GetRecTracksPtr(void) const {return fRecTracksPtr;} // Array
+ // Reconstructed trigger tracks
+ Int_t GetNRecTriggerTracks() const {return fNRecTriggerTracks;} // Number
+ void SetNRecTriggerTracks(Int_t NRecTriggerTracks) {fNRecTriggerTracks = NRecTriggerTracks;}
+ TClonesArray* GetRecTriggerTracksPtr(void) const {return fRecTriggerTracksPtr;} // Array
+
// Hits on reconstructed tracks
Int_t GetNRecTrackHits() const {return fNRecTrackHits;} // Number
void SetNRecTrackHits(Int_t NRecTrackHits) {fNRecTrackHits = NRecTrackHits;}
Double_t GetImpactParamFromBendingMomentum(Double_t BendingMomentum) const;
Double_t GetBendingMomentumFromImpactParam(Double_t ImpactParam) const;
void EventReconstruct(void);
+ void EventReconstructTrigger(void);
void EventDump(void); // dump reconstructed event
+ void EventDumpTrigger(void); // dump reconstructed trigger event
void FillEvent(); // fill and write tree of reconstructed events
void SetTrackMethod(Int_t TrackMethod) {fTrackMethod = TrackMethod;} //AZ
Int_t GetTrackMethod(void) const {return fTrackMethod;} //AZ
TClonesArray *fRecTracksPtr; // pointer to array of reconstructed tracks
Int_t fNRecTracks; // number of reconstructed tracks
+ // Reconstructed trigger tracks
+ TClonesArray *fRecTriggerTracksPtr; // pointer to array of reconstructed trigger tracks
+ Int_t fNRecTriggerTracks; // number of reconstructed trigger tracks
+
// Track hits on reconstructed tracks
TClonesArray *fRecTrackHitsPtr; // pointer to array of hits on reconstructed tracks
Int_t fNRecTrackHits; // number of hits on reconstructed tracks
void ResetSegments(void);
void MakeSegmentsPerStation(Int_t Station);
void MakeTracks(void);
+ void MakeTriggerTracks(void);
void ResetTrackHits(void);
void ResetTracks(void);
+ void ResetTriggerTracks(void);
Int_t MakeTrackCandidatesWithTwoSegments(AliMUONSegment *BegSegment);
Int_t MakeTrackCandidatesWithOneSegmentAndOnePoint(AliMUONSegment *BegSegment);
void MakeTrackCandidates(void);
AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
// MUONLoader->LoadHits("READ");
MUONLoader->LoadRecPoints("READ");
+ MUONLoader->LoadTracks("UPDATE");
AliMUONData * muondata = MUON->GetMUONData();
muondata->SetLoader(MUONLoader);
- Int_t ievent, nevents;
+ Int_t nevents;
nevents = RunLoader->GetNumberOfEvents();
AliMUONEventReconstructor *Reco = new AliMUONEventReconstructor();
// with respect to the default ones
// Reco->SetMaxSigma2Distance(100.0);
// Reco->SetPrintLevel(20);
- Reco->SetPrintLevel(1);
+ Reco->SetPrintLevel(0);
// Reco->SetBendingResolution(0.0);
// Reco->SetNonBendingResolution(0.0);
cout << "AliMUONEventReconstructor: actual parameters" << endl;
- Reco->Dump();
+// Reco->Dump();
// gObjectTable->Print();
+ MUONLoader->LoadRecPoints("READ");
+
if (LastEvent>nevents) LastEvent=nevents;
// Loop over events
for (Int_t event = FirstEvent; event < LastEvent; event++) {
- //MUONLoader->LoadHits("READ");
- MUONLoader->LoadRecPoints("READ");
- cout << "Event: " << event << endl;
- RunLoader->GetEvent(event);
- muondata->SetTreeAddress("RC");
- if (MUONLoader->TreeT() == 0x0) MUONLoader->MakeTree("T");
- muondata->MakeBranch("RT");
- muondata->SetTreeAddress("RT");
- Reco->EventReconstruct();
- // Dump current event
- Reco->EventDump();
+ //MUONLoader->LoadHits("READ");
+ cout << "Event: " << event << endl;
+ RunLoader->GetEvent(event);
+// Test if trigger track has already been done before
+ if (MUONLoader->TreeT() == 0x0) {
+ MUONLoader->MakeTracksContainer();
+ } else {
+ if (muondata->IsTrackBranchesInTree()){ // Test if track has already been done before
+ if (event==FirstEvent) MUONLoader->UnloadTracks();
+ MUONLoader->MakeTracksContainer(); // Redoing Tracking
+ Info("TrackContainer","Recreating TrackContainer and deleting previous ones");
+ }
+ }
- // Duplicating rectrack data in muondata for output
- for(Int_t i=0; i<Reco->GetNRecTracks(); i++) {
- AliMUONTrack * track = (AliMUONTrack*) Reco->GetRecTracksPtr()->At(i);
- muondata->AddRecTrack(*track);
- //printf(">>> TEST TEST event %d Number of hits in the track %d is %d \n",event,i,track->GetNTrackHits());
- }
+ muondata->MakeBranch("RT");
+ muondata->SetTreeAddress("D,RT");
+ Reco->EventReconstruct();
+ // Dump current event
+ // Reco->EventDump();
+
+ // Duplicating rectrack data in muondata for output
+ for(Int_t i=0; i<Reco->GetNRecTracks(); i++) {
+ AliMUONTrack * track = (AliMUONTrack*) Reco->GetRecTracksPtr()->At(i);
+ muondata->AddRecTrack(*track);
+ //printf(">>> TEST TEST event %d Number of hits in the track %d is %d \n",event,i,track->GetNTrackHits());
+ }
muondata->Fill("RT");
MUONLoader->WriteTracks("OVERWRITE");
muondata->ResetRecTracks();
- //MUONLoader->UnloadHits();
- MUONLoader->UnloadRecPoints();
+ muondata->ResetRawClusters();
} // Event loop
+ MUONLoader->UnloadRecPoints();
+ MUONLoader->UnloadTracks();
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff