"Creating standard getter for detector %s. Top folder is %s.",
GetName(),topfoldername);
- fLoader = new AliLoader(GetName(),topfoldername);
+ fLoader = new AliMUONLoader(GetName(),topfoldername);
fMUONData = new AliMUONData(fLoader,GetName(),GetName());
return fLoader;
}
delete decision;
// fLoader->TreeR()->Fill();
- fLoader->TreeR()->GetBranch("MUONGlobalTrigger")->Fill();
- fLoader->TreeR()->GetBranch("MUONLocalTrigger")->Fill();
-
-
+ GetMUONData()->Fill("GLT"); //Filling Global and Local Trigger GLT
// char hname[30];
// sprintf(hname,"TreeR%d",nev);
// fLoader->TreeR()->Write(hname,TObject::kOverwrite);
{
FindClusters();
Int_t nev = gAlice->GetHeader()->GetEvent();
- fLoader->TreeR()->Fill();
- // char hname[30];
- // sprintf(hname,"TreeR%d", nev);
- //fLoader->TreeR()->Write(hname);
- //fLoader->TreeR()->Reset();
+ GetMUONData()->Fill("RC"); //Filling Reconstructed Cluster
fLoader->WriteRecPoints("OVERWRITE");
GetMUONData()->ResetRawClusters();
- printf("\n End of cluster finding for event %d", nev);
+ Info("Digits2Reco","End of cluster finding for event %d", nev);
}
//____________________________________________________________________
void AliMUON::FindClusters()
AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
ResetDigits();
- fLoader->TreeD()->GetEvent(0);
+ GetMUONData()->GetCathode(0);
//TClonesArray *
- muonDigits = GetMUONData()->Digits(ich,0); // cathode plane not yet operational
+ muonDigits = GetMUONData()->Digits(ich);
ndig=muonDigits->GetEntriesFast();
printf("\n 1 Found %d digits in %p chamber %d", ndig, muonDigits,ich);
TClonesArray &lhits1 = *dig1;
if (rec->TestTrack(digit->Track(0)))
new(lhits1[n++]) AliMUONDigit(*digit);
}
- ResetDigits();
- fLoader->TreeD()->GetEvent(1);
- //muonDigits = this->DigitsAddress(ich);
- muonDigits = GetMUONData()->Digits(ich,1); // cathode plane not yet operational
+ GetMUONData()->ResetDigits();
+ GetMUONData()->GetCathode(1);
+ muonDigits = GetMUONData()->Digits(ich);
ndig=muonDigits->GetEntriesFast();
printf("\n 2 Found %d digits in %p %d", ndig, muonDigits, ich);
TClonesArray &lhits2 = *dig2;
newchamber:
if (ch > 9) {if (fReco) return; nev++; ch = 0; goto newev;}
//gAlice->ResetDigits();
- fMuonDigits = MUON->GetMUONData()->Digits(ch,0);
+ fMuonDigits = MUON->GetMUONData()->Digits(ch);
if (fMuonDigits == 0) return;
iChamber = &(MUON->Chamber(ch));
fSegmentation[0] = iChamber->SegmentationModel(1);
Int_t cath = TMath::Odd(iii);
gAlice->ResetDigits();
TD->GetEvent(cath);
- fMuonDigits = MUON->GetMUONData()->Digits(ch,0);
+ fMuonDigits = MUON->GetMUONData()->Digits(ch);
ndigits[cath] = fMuonDigits->GetEntriesFast();
if (!ndigits[0] && !ndigits[1]) {if (fReco) return; ch++; goto newchamber;}
-
//Root includes
-
+#include "TNamed.h"
//AliRoot includes
+#include "AliLoader.h"
+#include "AliMUONConstants.h"
#include "AliMUONData.h"
#include "AliMUONDigit.h"
#include "AliMUONHit.h"
//
// Add a MUON digit to the list of Digits of the detection plane id
//
- TClonesArray &ldigits = * Digits(id,0) ;
+ TClonesArray &ldigits = * Digits(id) ;
new(ldigits[fNdigits[id]++]) AliMUONDigit(tracks,charges,digits);
}
//_____________________________________________________________________________
new(lrectracks[fNrectracks++]) AliMUONTrack(track);
}
//____________________________________________________________________________
+void AliMUONData::Fill(Option_t* option)
+{
+ // Method to fill the trees
+ 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 *cRP = strstr(option,"RP"); // Reconstructed Particle in TreeP
+
+ char branchname[30];
+ TBranch * branch = 0x0;
+
+ //
+ // Filling TreeH
+ if ( TreeH() && cH ) {
+ TreeH()->Fill();
+ }
+ //
+ // Filling TreeD
+ if ( TreeD() && cD) {
+ TreeD()->Fill();
+ }
+ //
+ // filling rawclusters
+ if ( TreeR() && cRC) {
+ TreeR()->Fill();
+ // for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
+// sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
+// branch = TreeR()->GetBranch(branchname);
+// branch->Fill();
+// }
+ }
+ //
+ // filling trigger
+ if ( TreeR() && cGLT) {
+ sprintf(branchname,"%sLocalTrigger",GetName());
+ branch = TreeR()->GetBranch(branchname);
+ branch->Fill();
+ sprintf(branchname,"%sGlobalTrigger",GetName());
+ branch = TreeR()->GetBranch(branchname);
+ branch->Fill();
+ }
+ //
+ // filling tracks
+ if ( TreeT() && cRT ) {
+ sprintf(branchname,"%sTrack",GetName());
+ branch = TreeT()->GetBranch(branchname);
+ branch->Fill();
+ }
+}
+//_____________________________________________________________________________
void AliMUONData::MakeBranch(Option_t* option)
{
//
Info("MakeBranch","Branch %s is already in tree.",GetName());
return;
}
- TClonesArray * digits = Digits(iDetectionPlane,0);
+ TClonesArray * digits = Digits(iDetectionPlane);
branch = TreeD()->Branch(branchname, &digits, kBufferSize);
Info("MakeBranch","Making Branch %s for digits in detection plane %d\n",branchname,iDetectionPlane+1);
}
for (int i=0; i<AliMUONConstants::NCh(); i++) {
sprintf(branchname,"%sDigits%d",GetName(),i+1);
branch = TreeD()->GetBranch(branchname);
- TClonesArray * digits = Digits(i,0);
+ TClonesArray * digits = Digits(i);
if (branch) branch->SetAddress( &digits );
else Warning("SetTreeAddress","(%s) Failed for Digits Detection plane %d. Can not find branch in tree.",GetName(),i);
}
// Gines Martinez, Subatech, September 2003
//
-#include "TNamed.h"
-
-#include "AliLoader.h"
-#include "AliMUONConstants.h"
+#include "AliLoader.h"
class TClonesArray;
+class TNamed;
class TObjArray;
class TTree;
+
+class AliMUONConstants;
class AliMUONRawCluster;
class AliMUONTrack;
virtual void AddRecTrack(const AliMUONTrack& track);
TClonesArray* Hits() {return fHits;}
- TClonesArray* Digits(Int_t DetectionPlane, Int_t /*Cathode*/)
+ TClonesArray* Digits(Int_t DetectionPlane)
{return ( (TClonesArray*) fDigits->At(DetectionPlane) );}
TClonesArray* LocalTrigger() {return fLocalTrigger;}
TClonesArray* GlobalTrigger() {return fGlobalTrigger;}
TClonesArray* RawClusters(Int_t DetectionPlane)
{return ( (TClonesArray*) fRawClusters->At(DetectionPlane) );}
TClonesArray* RecTracks() {return fRecTracks;}
-
+
+ void GetTrack(Int_t it) {fLoader->TreeH()->GetEvent(it);}
+ Int_t GetNtracks() {return fLoader->TreeH()->GetEntries();}
+ void GetCathode(Int_t ic) {fLoader->TreeD()->GetEvent(ic);}
+ void GetRawClusters() {fLoader->TreeR()->GetEvent(0);}
+ void GetTrigger() {fLoader->TreeR()->GetEvent(0);}
+
virtual AliLoader* GetLoader() {return fLoader;}
virtual void SetLoader(AliLoader * loader) {fLoader=loader;}
+ virtual void Fill(Option_t* opt=" ");
virtual void MakeBranch(Option_t *opt=" ");
virtual void SetTreeAddress(Option_t *opt=" ");
if ( digits[2] == icat ) muondata->AddDigit(ich,tracks,charges,digits);
}
// Filling list of digits per chamber for a given cathode.
- treeD->Fill();
+ muondata->Fill("D");
muondata->ResetDigits();
} // end loop cathode
fTDList->Delete();
AliSegmentation* segmentation;
AliMUONResponse* response;
- TClonesArray *muonDigits = pMUON->GetMUONData()->Digits(chamber-1,0);
+ TClonesArray *muonDigits = pMUON->GetMUONData()->Digits(chamber-1);
if (muonDigits == 0) return;
// gAlice->ResetDigits();
Int_t nent = 0;
- if (gAlice->TreeD()) {
- nent = (Int_t) gAlice->TreeD()->GetEntries();
+ if (pMUON->GetLoader()->TreeD()) {
+ nent = (Int_t) pMUON->GetLoader()->TreeD()->GetEntries();
printf(" entries %d \n", nent);
// gAlice->TreeD()->GetEvent(nent-2+cathode-1);
- gAlice->TreeD()->GetEvent(cathode-1);
+ pMUON->GetMUONData()->GetCathode(cathode-1);
}
Int_t ndigits = muonDigits->GetEntriesFast();
//AliRoot includes
#include "AliMUONLoader.h"
+#include "AliMUONConstants.h"
ClassImp(AliMUONLoader)
//___________________________________________________________________
-
-
-/*****************************************************************************/
AliMUONLoader::AliMUONLoader():AliLoader()
{
//default constructor
-
}
-/******************************************************************/
-
+//_______________________________________________________________________________
AliMUONLoader::AliMUONLoader(const Char_t* detname,const Char_t* eventfoldername):AliLoader(detname,eventfoldername)
{
-
}
-/*****************************************************************************/
-
+//_______________________________________________________________________________
AliMUONLoader::AliMUONLoader(const Char_t * detname,TFolder* eventfolder):AliLoader(detname,eventfolder)
{
//constructor
-
}
-/*****************************************************************************/
-
+//_______________________________________________________________________________
AliMUONLoader::~AliMUONLoader()
{
//detructor
}
-/*****************************************************************************/
-
+//_______________________________________________________________________________
// //
/////////////////////////////////////////////////////////////////////
-class TClonesArray;
-
class AliMUONData;
+
class AliMUONLoader : public AliLoader {
public:
AliMUONLoader();
AliMUONLoader(const Char_t *detname,TFolder* eventfolder);
virtual ~AliMUONLoader();
+
private:
//descendant classes should
//use protected interface methods to access these folders
Int_t cathode=display->GetCathode();
AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
- TClonesArray *muonDigits = pMUON->GetMUONData()->Digits(chamber-1,0);
+ TClonesArray *muonDigits = pMUON->GetMUONData()->Digits(chamber-1);
Int_t nent=(Int_t)gAlice->TreeD()->GetEntries();
- gAlice->TreeD()->GetEvent(nent-2+cathode-1);
+ pMUON->GetMUONData()->GetCathode(nent-2+cathode-1);
//gAlice->TreeD()->GetEvent(cathode);
Int_t ndigits = muonDigits->GetEntriesFast();
if (fDigitIndex < 0 || fDigitIndex >= ndigits) return 0;
AliMUONChamber* iChamber = &(pMUON->Chamber(chamber-1));
AliSegmentation* segmentation;
gime->TreeD()->GetEvent(cathode-1);
- TClonesArray *muonDigits = pMUON->GetMUONData()->Digits(chamber-1,0);
+ TClonesArray *muonDigits = pMUON->GetMUONData()->Digits(chamber-1);
Int_t ndigits = muonDigits->GetEntriesFast();
printf("\n 1 Found %d digits in %p %d \n ", ndigits, muonDigits,chamber-1);
// if (ndigits == 0) return;
printf(">>> Error : Error Opening %s file \n",filename);
return;
}
-
// Loading MUON subsystem
AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
- MUONLoader->LoadHits("READ");
- // Creating MUON data container
- AliMUONData muondata(MUONLoader,"MUON","MUON");
-
+ MUONLoader->LoadHits("READ"); // Loading Tree of hits for MUON
+ AliMUONData muondata(MUONLoader,"MUON","MUON"); // Creating MUON data container
Int_t ievent, nevents;
nevents = RunLoader->GetNumberOfEvents();
for(ievent=0; ievent<nevents; ievent++) { // Event loop
printf(">>> Event %d \n",ievent);
-
// Getting event ievent
RunLoader->GetEvent(ievent);
muondata.SetTreeAddress("H");
-
Int_t itrack, ntracks;
- ntracks = (Int_t) (MUONLoader->TreeH())->GetEntries();
+ ntracks = (Int_t) muondata.GetNtracks();
for (itrack=0; itrack<ntracks; itrack++) { // Track loop
printf(">>> Track %d \n",itrack);
//Getting List of Hits of Track itrack
- (MUONLoader->TreeH())->GetEvent(itrack);
+ muondata.GetTrack(itrack);
Int_t ihit, nhits;
nhits = (Int_t) muondata.Hits()->GetEntriesFast();
// Loading MUON subsystem
AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
MUONLoader->LoadDigits("READ");
-
// Creating MUON data container
AliMUONData muondata(MUONLoader,"MUON","MUON");
Int_t ievent, nevents;
nevents = RunLoader->GetNumberOfEvents();
-
AliMUONDigit * mDigit;
-
for(ievent=0; ievent<nevents; ievent++) {
printf(">>> Event %d \n",ievent);
RunLoader->GetEvent(ievent);
//Loop on cathodes
for(icathode=0; icathode<ncathodes; icathode++) {
printf(">>> Cathode %d\n",icathode);
- MUONLoader->TreeD()->GetEvent(icathode);
+ muondata.GetCathode(icathode);
// Loop on chambers
for( ichamber=0; ichamber<nchambers; ichamber++) {
printf(">>> Chamber %d\n",ichamber);
- // sprintf(branchname,"MUONDigits%d",ichamber+1);
- //printf(">>> branchname %s\n",branchname);
Int_t idigit, ndigits;
-
- ndigits = (Int_t) muondata.Digits(ichamber,0)->GetEntriesFast();
+ ndigits = (Int_t) muondata.Digits(ichamber)->GetEntriesFast();
for(idigit=0; idigit<ndigits; idigit++) {
- mDigit = static_cast<AliMUONDigit*>(muondata.Digits(ichamber,0)->At(idigit));
+ mDigit = static_cast<AliMUONDigit*>(muondata.Digits(ichamber)->At(idigit));
Int_t PadX = mDigit->PadX(); // Pad X number
Int_t PadY = mDigit->PadY(); // Pad Y number
Int_t Signal = mDigit->Signal(); // Physics Signal
Int_t ievent, nevents;
nevents = RunLoader->GetNumberOfEvents();
-
AliMUONRawCluster * mRecPoint;
for(ievent=0; ievent<nevents; ievent++) {
printf(">>> Event %d \n",ievent);
RunLoader->GetEvent(ievent);
-
// Addressing
Int_t ichamber, nchambers;
nchambers = AliMUONConstants::NTrackingCh();
muondata.SetTreeAddress("RC");
char branchname[30];
- MUONLoader->TreeR()->GetEvent(0);
+ muondata.GetRawClusters();
// Loop on chambers
for( ichamber=0; ichamber<nchambers; ichamber++) {
printf(">>> Chamber %d\n",ichamber);
//printf(">>> branchname %s\n",branchname);
Int_t irecpoint, nrecpoints;
-
nrecpoints = (Int_t) muondata.RawClusters(ichamber)->GetEntriesFast();
for(irecpoint=0; irecpoint<nrecpoints; irecpoint++) {
RunLoader->GetEvent(ievent);
muondata.SetTreeAddress("GLT");
- MUONLoader->TreeR()->GetEvent(0);
+ muondata.GetTrigger();
globalTrigger = muondata.GlobalTrigger();
localTrigger = muondata.LocalTrigger();
muondata->AddRecTrack(*track);
}
- MUONLoader->TreeT()->Fill();
+ muondata->Fill("RT");
MUONLoader->WriteTracks("OVERWRITE");
muondata->ResetRecTracks();
} // Event loop