**************************************************************************/
/* $Id$ */
+// AliMUONData classes
+// Class containing MUON data: hits, digits, rawclusters, globaltrigger, localtrigger, etc ..
+// The classe makes the lik between the MUON data lists and the event trees from loaders
+// Gines Martinez, Subatech, September 2003
+//
-//Root includes
-#include "TNamed.h"
-//AliRoot includes
-#include "AliLoader.h"
+//AliRoot include
+//#include "AliRun.h"
+//#include "AliMC.h"
#include "AliMUONConstants.h"
#include "AliMUONData.h"
#include "AliMUONDigit.h"
#include "AliMUONGlobalTrigger.h"
#include "AliMUONRawCluster.h"
#include "AliMUONTrack.h"
+#include "AliMUONTriggerTrack.h"
+#include "AliLog.h"
ClassImp(AliMUONData)
//_____________________________________________________________________________
-AliMUONData::AliMUONData():TNamed()
-{
- fLoader = 0x0;
- fHits = 0x0; // One event in treeH per primary track
- fDigits = 0x0; // One event in treeH per detection plane
- fNdigits = 0x0;
- fRawClusters = 0x0; //One event in TreeR/RawclusterBranch per tracking detection plane
- fGlobalTrigger = 0x0; //! List of Global Trigger 1st event in TreeR/GlobalTriggerBranch
- fLocalTrigger = 0x0; //! List of Local Trigger, 1st event in TreeR/LocalTriggerBranch
- fRecTracks = 0x0;
-//default constructor
+ AliMUONData::AliMUONData():
+ TNamed(),
+ fLoader(0x0),
+ fHits(0x0),
+ fDigits(0x0),
+ fSDigits(0x0),
+ fRawClusters(0x0),
+ fGlobalTrigger(0x0),
+ fLocalTrigger(0x0),
+ fRecTracks(0x0),
+ fRecTriggerTracks(0x0),
+ fNhits(0),
+ fNdigits(0x0),
+ fNSdigits(0x0),
+ fNrawclusters(0x0),
+ fNglobaltrigger(0),
+ fNlocaltrigger(0),
+ fNrectracks(0),
+ fNrectriggertracks(0),
+ fSplitLevel(0)
+{
+ // Default constructor
}
//_____________________________________________________________________________
AliMUONData::AliMUONData(AliLoader * loader, const char* name, const char* title):
- TNamed(name,title)
-{
- fLoader = loader;
- fHits = 0x0; // One event in treeH per primary track
- fDigits = 0x0; // One event in treeH per detection plane
- fNdigits = 0x0;
- fRawClusters = 0x0; //One event in TreeR/RawclusterBranch per tracking detection plane
- fGlobalTrigger = 0x0; //! List of Global Trigger 1st event in TreeR/GlobalTriggerBranch
- fLocalTrigger = 0x0; //! List of Local Trigger, 1st event in TreeR/LocalTriggerBranch
- fRecTracks = 0x0;
- fNhits = 0;
- fNglobaltrigger =0;
- fNlocaltrigger = 0;
- fNrectracks = 0;
+ TNamed(name,title),
+ fLoader(loader),
+ fHits(0x0),
+ fDigits(0x0),
+ fSDigits(0x0),
+ fRawClusters(0x0),
+ fGlobalTrigger(0x0),
+ fLocalTrigger(0x0),
+ fRecTracks(0x0),
+ fRecTriggerTracks(0x0),
+ fNhits(0),
+ fNdigits(0x0),
+ fNSdigits(0x0),
+ fNrawclusters(0x0),
+ fNglobaltrigger(0),
+ fNlocaltrigger(0),
+ fNrectracks(0),
+ fNrectriggertracks(0),
+ fSplitLevel(0)
+{
+ // Constructor for AliMUONData
+
// fHits = new TClonesArray("AliMUONHit",1000);
// fNhits = 0;
// fDigits = new TObjArray(AliMUONConstants::NCh());
// fNglobaltrigger =0;
// fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
// fNlocaltrigger = 0;
-// fRecTracks = new TClonesArray("AliMUONTrack", 10);
+// fRecTracks = new TClonesArray("AliMUONTrack", 100);
// fNrectracks = 0; // really needed or GetEntriesFast sufficient ????
- //default constructor
}
+
//_____________________________________________________________________________
AliMUONData::AliMUONData(const AliMUONData& rMUONData):TNamed(rMUONData)
{
- // Dummy copy constructor
- ;
+// Protected copy constructor
+
+ AliFatal("Not implemented.");
}
+
//_____________________________________________________________________________
AliMUONData::~AliMUONData()
{
+ // Destructor for AliMUONData
if (fHits) {
fHits->Delete();
delete fHits;
fDigits->Delete();
delete fDigits;
}
+ if (fSDigits) {
+ fSDigits->Delete();
+ delete fSDigits;
+ }
if (fRawClusters) {
fRawClusters->Delete();
delete fRawClusters;
fRecTracks->Delete();
delete fRecTracks;
}
+ if (fRecTriggerTracks){
+ fRecTriggerTracks->Delete();
+ delete fRecTriggerTracks;
+ }
//detructor
}
+
+//_____________________________________________________________________________
+AliMUONData& AliMUONData::operator=(const AliMUONData& rhs)
+{
+// Protected assignement operator
+
+ if (this == &rhs) return *this;
+
+ AliFatal("Not implemented.");
+
+ return *this;
+}
+
+
//_____________________________________________________________________________
void AliMUONData::AddDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
{
new(ldigits[fNdigits[id]++]) AliMUONDigit(tracks,charges,digits);
}
//_____________________________________________________________________________
+void AliMUONData::AddDigit(Int_t id, const AliMUONDigit& digit)
+{
+ //
+ // Add a MUON digit to the list of Digits of the detection plane id
+ //
+ TClonesArray &ldigits = * Digits(id) ;
+ new(ldigits[fNdigits[id]++]) AliMUONDigit(digit);
+}
+//_____________________________________________________________________________
+void AliMUONData::AddSDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *sdigits)
+{
+ //
+ // Add a MUON Sdigit to the list of SDigits of the detection plane id
+ //
+ TClonesArray &lSdigits = * SDigits(id) ;
+ new(lSdigits[fNSdigits[id]++]) AliMUONDigit(tracks,charges,sdigits);
+}
+//_____________________________________________________________________________
+void AliMUONData::AddSDigit(Int_t id, const AliMUONDigit& Sdigit)
+{
+ //
+ // Add a MUON Sdigit to the list of SDigits of the detection plane id
+ //
+ TClonesArray &lSdigits = * SDigits(id) ;
+ new(lSdigits[fNSdigits[id]++]) AliMUONDigit(Sdigit);
+}
+//_____________________________________________________________________________
void AliMUONData::AddGlobalTrigger(Int_t *singlePlus, Int_t *singleMinus,
Int_t *singleUndef,
Int_t *pairUnlike, Int_t *pairLike)
{
// add a MUON Global Trigger to the list (only one GlobalTrigger per event !)
+
TClonesArray &globalTrigger = *fGlobalTrigger;
new(globalTrigger[fNglobaltrigger++])
AliMUONGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike, pairLike);
}
//_____________________________________________________________________________
+void AliMUONData::AddGlobalTrigger(const AliMUONGlobalTrigger& trigger )
+{
+ // add a MUON Global Trigger to the list (only one GlobalTrigger per event !);
+ TClonesArray &globalTrigger = *fGlobalTrigger;
+ new(globalTrigger[fNglobaltrigger++]) AliMUONGlobalTrigger(trigger);
+}
+//____________________________________________________________________________
void AliMUONData::AddHit(Int_t fIshunt, Int_t track, Int_t iChamber,
Int_t idpart, Float_t X, Float_t Y, Float_t Z,
Float_t tof, Float_t momentum, Float_t theta,
- Float_t phi, Float_t length, Float_t destep)
+ Float_t phi, Float_t length, Float_t destep,
+ Float_t Xref,Float_t Yref,Float_t Zref)
{
+ // Add new hit to the hit list
TClonesArray &lhits = *fHits;
new(lhits[fNhits++]) AliMUONHit(fIshunt, track, iChamber,
idpart, X, Y, Z,
tof, momentum, theta,
- phi, length, destep);
+ phi, length, destep,
+ Xref,Yref,Zref);
+}
+//____________________________________________________________________________
+void AliMUONData::AddHit2(Int_t fIshunt, Int_t track, Int_t detElemId,
+ Int_t idpart, Float_t X, Float_t Y, Float_t Z,
+ Float_t tof, Float_t momentum, Float_t theta,
+ Float_t phi, Float_t length, Float_t destep,
+ Float_t Xref,Float_t Yref,Float_t Zref)
+{
+ // Add new hit to the hit list
+ TClonesArray &lhits = *fHits;
+ new(lhits[fNhits++]) AliMUONHit(fIshunt, track, detElemId,
+ idpart, X, Y, Z,
+ tof, momentum, theta,
+ phi, length, destep,
+ Xref,Yref,Zref, true);
}
//____________________________________________________________________________
-void AliMUONData::AddLocalTrigger(Int_t *localtr)
+void AliMUONData::AddLocalTrigger(const Int_t *localtr, const TArrayI& digits)
{
// add a MUON Local Trigger to the list
TClonesArray &localTrigger = *fLocalTrigger;
- new(localTrigger[fNlocaltrigger++]) AliMUONLocalTrigger(localtr);
+ new(localTrigger[fNlocaltrigger++]) AliMUONLocalTrigger(localtr, digits);
+}
+//____________________________________________________________________________
+void AliMUONData::AddLocalTrigger(const AliMUONLocalTrigger& trigger)
+{
+ // add a MUON Local Trigger to the list
+ TClonesArray &localTrigger = *fLocalTrigger;
+ new(localTrigger[fNlocaltrigger++]) AliMUONLocalTrigger(trigger);
}
//_____________________________________________________________________________
void AliMUONData::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
//
TClonesArray &lrectracks = *fRecTracks;
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)
+{
+ //Getting List of Digits
+ if (fDigits)
+ return ( (TClonesArray*) fDigits->At(DetectionPlane) );
+ else
+ return NULL;
+}
+//____________________________________________________________________________
+TClonesArray* AliMUONData::SDigits(Int_t DetectionPlane)
+{
+ //Getting List of SDigits
+ if (fSDigits)
+ return ( (TClonesArray*) fSDigits->At(DetectionPlane) );
+ else
+ return NULL;
}
//____________________________________________________________________________
Bool_t AliMUONData::IsRawClusterBranchesInTree()
{
+ // Checking if there are RawCluster Branches In TreeR
if (TreeR()==0x0) {
- Error("TreeR","No treeR in memory");
+ AliError("No treeR in memory");
return kFALSE;
}
else {
}
}
//____________________________________________________________________________
+Bool_t AliMUONData::IsDigitsBranchesInTree()
+{
+ // Checking if there are RawCluster Branches In TreeR
+ if (TreeD()==0x0) {
+ AliError("No treeD in memory");
+ return kFALSE;
+ }
+ else {
+ char branchname[30];
+ sprintf(branchname,"%sDigits1",GetName());
+ TBranch * branch = 0x0;
+ branch = TreeD()->GetBranch(branchname);
+ if (branch) return kTRUE;
+ else return kFALSE;
+ }
+}
+//____________________________________________________________________________
Bool_t AliMUONData::IsTriggerBranchesInTree()
{
+ // Checking if there are Trigger Branches In TreeR
if (TreeR()==0x0) {
- Error("TreeR","No treeR in memory");
+ AliError("No treeR in memory");
return kFALSE;
}
else {
}
}
//____________________________________________________________________________
+Bool_t AliMUONData::IsTriggerBranchesInTreeD()
+{
+ // Checking if there are Trigger Branches In TreeR
+ if (TreeD()==0x0) {
+ AliError("No treeD in memory");
+ return kFALSE;
+ }
+ else {
+ char branchname[30];
+ sprintf(branchname,"%sLocalTrigger",GetName());
+ TBranch * branch = 0x0;
+ branch = TreeD()->GetBranch(branchname);
+ if (branch) return kTRUE;
+ else return kFALSE;
+ }
+}
+
+//____________________________________________________________________________
+Bool_t AliMUONData::IsTrackBranchesInTree()
+{
+ // Checking if there are Track Branches In TreeT
+ if (TreeT()==0x0) {
+ AliError("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) {
+ AliError("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 *cH = strstr(option,"H");
const char *cD = strstr(option,"D"); // Digits branches in TreeD
+ const char *cS = strstr(option,"S"); // SDigits branches in 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 *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeD
+ const char *cTC = strstr(option,"TC"); // global and local Trigger branches Copy 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
char branchname[30];
TBranch * branch = 0x0;
- //
// Filling TreeH
if ( TreeH() && cH ) {
TreeH()->Fill();
}
- //
+
// Filling TreeD
- if ( TreeD() && cD) {
- TreeD()->Fill();
+
+ if ( TreeD() && cD ) {
+ if ( IsTriggerBranchesInTreeD() ) {
+ for (int i=0; i<AliMUONConstants::NCh(); i++) {
+ sprintf(branchname,"%sDigits%d",GetName(),i+1);
+ branch = TreeD()->GetBranch(branchname);
+ branch->Fill();
+ }
+ } else
+ TreeD()->Fill();
+ }
+
+ // filling trigger
+ if ( TreeD() && cGLT ) {
+ if ( IsDigitsBranchesInTree() ) {
+ sprintf(branchname,"%sLocalTrigger",GetName());
+ branch = TreeD()->GetBranch(branchname);
+ branch->Fill();
+ sprintf(branchname,"%sGlobalTrigger",GetName());
+ branch = TreeD()->GetBranch(branchname);
+ branch->Fill();
+ } else
+ TreeD()->Fill();
+ }
+
+ // Filling TreeS
+ if ( TreeS() && cS) {
+ TreeS()->Fill();
}
//
//
// filling trigger
- if ( TreeR() && cGLT) {
+ if ( TreeR() && cTC) {
if (IsRawClusterBranchesInTree()) {
// Branch per branch filling
sprintf(branchname,"%sLocalTrigger",GetName());
//
// filling tracks
if ( TreeT() && cRT ) {
- sprintf(branchname,"%sTrack",GetName());
- branch = TreeT()->GetBranch(branchname);
- branch->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() && cRL ) {
+// sprintf(branchname,"%sTrackTrig",GetName());
+// TreeT()->Fill();
+// }
}
//_____________________________________________________________________________
void AliMUONData::MakeBranch(Option_t* option)
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 *cS = strstr(option,"S"); // Digits branches in 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 *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeD
+ const char *cTC = strstr(option,"TC"); // global and local Trigger branches Copy in TreeR
const char *cRT = strstr(option,"RT"); // Reconstructed Track in TreeT
- const char *cRP = strstr(option,"RP"); // Reconstructed Particle in TreeP
-
+ 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
if (TreeH() && cH) {
- if (fHits == 0x0) fHits = new TClonesArray("AliMUONHit",1000);
+
+ if (fHits == 0x0) {
+ fHits = new TClonesArray("AliMUONHit",1000);
+// if (gAlice->GetMCApp())
+// gAlice->GetMCApp()->AddHitList (fHits);
+ }
+
fNhits = 0;
sprintf(branchname,"%sHits",GetName());
branch = TreeH()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch %s is already in tree.",GetName());
+ AliInfo(Form("MakeBranch","Branch %s is already in tree.",GetName()));
return ;
}
branch = TreeH()->Branch(branchname,&fHits,kBufferSize);
- Info("MakeBranch","Making Branch %s for hits \n",branchname);
+ //Info("MakeBranch","Making Branch %s for hits \n",branchname);
}
//Creating Branches for Digits
if (fDigits == 0x0) {
fDigits = new TObjArray(AliMUONConstants::NCh());
for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
- fDigits->AddAt(new TClonesArray("AliMUONDigit",10000),iDetectionPlane);
+ TClonesArray * tca = new TClonesArray("AliMUONDigit",10000);
+ tca->SetOwner();
+ fDigits->AddAt(tca,iDetectionPlane);
}
}
if (fNdigits == 0x0) {
branch = 0x0;
branch = TreeD()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch %s is already in tree.",GetName());
+ AliInfo(Form("Branch %s is already in tree.",GetName()));
return;
}
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);
+ branch = TreeD()->Branch(branchname, &digits, kBufferSize,1);
+ //Info("MakeBranch","Making Branch %s for digits in detection plane %d\n",branchname,iDetectionPlane+1);
}
}
-
+
+ if (TreeD() && cGLT ) {
+ //
+ // one branch for global trigger
+ //
+ sprintf(branchname,"%sGlobalTrigger",GetName());
+ branch = 0x0;
+
+ if (fGlobalTrigger == 0x0) {
+ fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger");
+ fNglobaltrigger = 0;
+ }
+ branch = TreeD()->GetBranch(branchname);
+ if (branch) {
+ AliInfo(Form("Branch GlobalTrigger is already in treeD."));
+ return ;
+ }
+ branch = TreeD()->Branch(branchname, &fGlobalTrigger, kBufferSize);
+ //Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);
+
+ //
+ // one branch for local trigger
+ //
+ sprintf(branchname,"%sLocalTrigger",GetName());
+ branch = 0x0;
+
+ if (fLocalTrigger == 0x0) {
+ fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
+ fNlocaltrigger = 0;
+ }
+ branch = TreeD()->GetBranch(branchname);
+ if (branch) {
+ AliInfo(Form("Branch LocalTrigger is already in treeD."));
+ return;
+ }
+ branch = TreeD()->Branch(branchname, &fLocalTrigger, kBufferSize);
+ //Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);
+ }
+
+
+ //Creating Branches for SDigits
+ if (TreeS() && cS ) {
+ // one branch for Sdigits per chamber
+ if (fSDigits == 0x0) {
+ fSDigits = new TObjArray(AliMUONConstants::NCh());
+ for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
+ TClonesArray * tca = new TClonesArray("AliMUONDigit",10000);
+ tca->SetOwner();
+ fSDigits->AddAt(tca,iDetectionPlane);
+ }
+ }
+ if (fNSdigits == 0x0) {
+ fNSdigits = new Int_t[AliMUONConstants::NCh()];
+ for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
+ fNSdigits[iDetectionPlane]=0;
+ }
+ }
+ for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
+ sprintf(branchname,"%sSDigits%d",GetName(),iDetectionPlane+1);
+ branch = 0x0;
+ branch = TreeS()->GetBranch(branchname);
+ if (branch) {
+ AliInfo(Form("Branch %s is already in tree.",GetName()));
+ return;
+ }
+ TClonesArray * sdigits = SDigits(iDetectionPlane);
+ branch = TreeS()->Branch(branchname, &sdigits, kBufferSize,1);
+ //Info("MakeBranch","Making Branch %s for sdigits in detection plane %d\n",branchname,iDetectionPlane+1);
+ }
+ }
+
if (TreeR() && cRC ) {
// one branch for raw clusters per tracking detection plane
//
if (fRawClusters == 0x0) {
fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
- fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i);
+ TClonesArray * tca = new TClonesArray("AliMUONRawCluster",1000);
+ tca->SetOwner();
+ fRawClusters->AddAt(tca,i);
}
}
branch = 0x0;
branch = TreeR()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch %s is already in tree.",GetName());
+ AliInfo(Form("Branch %s is already in tree.",GetName()));
return;
}
branch = TreeR()->Branch(branchname, &((*fRawClusters)[i]),kBufferSize);
- Info("MakeBranch","Making Branch %s for rawcluster in detection plane %d\n",branchname,i+1);
+ //Info("MakeBranch","Making Branch %s for rawcluster in detection plane %d\n",branchname,i+1);
}
}
- if (TreeR() && cGLT ) {
+ if (TreeR() && cTC ) {
//
// one branch for global trigger
//
branch = 0x0;
if (fGlobalTrigger == 0x0) {
- fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
+ fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger");
fNglobaltrigger = 0;
}
branch = TreeR()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch %s is already in tree.",GetName());
+ AliInfo(Form("Branch GlobalTrigger is already in treeR."));
return ;
}
branch = TreeR()->Branch(branchname, &fGlobalTrigger, kBufferSize);
- Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);
+ //Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);
//
// one branch for local trigger
}
branch = TreeR()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch %s is already in tree.",GetName());
+ AliInfo(Form("Branch LocalTrigger is already in treeR."));
return;
}
branch = TreeR()->Branch(branchname, &fLocalTrigger, kBufferSize);
- Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);
+ //Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);
}
if (TreeT() && cRT ) {
- if (fRecTracks == 0x0) fRecTracks = new TClonesArray("AliMUONTrack",10);
+ if (fRecTracks == 0x0) fRecTracks = new TClonesArray("AliMUONTrack",100);
fNrectracks = 0;
sprintf(branchname,"%sTrack",GetName());
branch = TreeT()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch %s is already in tree.",GetName());
+ AliInfo(Form("Branch %s is already in tree.",GetName()));
return ;
}
branch = TreeT()->Branch(branchname,&fRecTracks,kBufferSize);
- Info("MakeBranch","Making Branch %s for tracks \n",branchname);
+ //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) {
+ AliInfo(Form("Branch %s is already in tree.",GetName()));
+ return ;
+ }
+ branch = TreeT()->Branch(branchname,&fRecTriggerTracks,kBufferSize);
+ //Info("MakeBranch","Making Branch %s for trigger tracks \n",branchname);
}
-
- if (TreeP() && cRP ) {
- Info("MakeBranch","Making Branch for TreeP is not yet ready. \n");
- }
}
-
+//____________________________________________________________________________
+TClonesArray* AliMUONData::RawClusters(Int_t DetectionPlane)
+{
+ // Getting Raw Clusters
+ if (fRawClusters)
+ return ( (TClonesArray*) fRawClusters->At(DetectionPlane) );
+ else
+ 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()
{
if (fNdigits) fNdigits[i]=0;
}
}
+//____________________________________________________________________________
+void AliMUONData::ResetSDigits()
+{
+ //
+ // Reset number of Sdigits and the Sdigits array for this detector
+ //
+ if (fSDigits == 0x0) return;
+ for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
+ if ((*fSDigits)[i]) ((TClonesArray*)fSDigits->At(i))->Clear();
+ if (fNSdigits) fNSdigits[i]=0;
+ }
+}
//______________________________________________________________________________
void AliMUONData::ResetHits()
{
{
// Reset tracks information
fNrectracks = 0;
- if (fRecTracks) fRecTracks->Clear();
+ if (fRecTracks) fRecTracks->Delete(); // necessary to delete in case of memory allocation
+}
+//____________________________________________________________________________
+void AliMUONData::ResetRecTriggerTracks()
+{
+ // Reset tracks information
+ fNrectriggertracks = 0;
+ if (fRecTriggerTracks) fRecTriggerTracks->Delete(); // necessary to delete in case of memory allocation
}
//_____________________________________________________________________________
void AliMUONData::SetTreeAddress(Option_t* option)
{
+ //Setting Addresses to the events trees
const char *cH = strstr(option,"H");
const char *cD = strstr(option,"D"); // Digits branches in TreeD
+ const char *cS = strstr(option,"S"); // SDigits branches in 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 *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeD
+ const char *cTC = strstr(option,"TC"); // global and local Trigger branches Copy 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.
//
// Branch address for hit tree
if ( TreeH() && cH ) {
- if (fHits == 0x0) fHits = new TClonesArray("AliMUONHit",1000);
+ if (fHits == 0x0) {
+ fHits = new TClonesArray("AliMUONHit",1000);
+ // if (gAlice->GetMCApp())
+ // gAlice->GetMCApp()->AddHitList (fHits); Moved to AliMUON
+ }
fNhits =0;
}
if (TreeH() && fHits && cH) {
sprintf(branchname,"%sHits",GetName());
branch = TreeH()->GetBranch(branchname);
if (branch) {
- Info("SetTreeAddress","(%s) Setting for Hits",GetName());
+ // Info("SetTreeAddress","(%s) Setting for Hits",GetName());
branch->SetAddress(&fHits);
}
else { //can be invoked before branch creation
- Warning("SetTreeAddress","(%s) Failed for Hits. Can not find branch in tree.",GetName());
+ AliWarning(Form("(%s) Failed for Hits. Can not find branch in tree.",GetName()));
}
}
//
// Branch address for digit tree
- if ( TreeD() && cD) {
- if (fDigits == 0x0) {
+ if ( TreeD() ) {
+ if (fDigits == 0x0 && cD) {
fDigits = new TObjArray(AliMUONConstants::NCh());
fNdigits= new Int_t[AliMUONConstants::NCh()];
for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
fNdigits[i]=0;
}
}
+ if (fLocalTrigger == 0x0 && cGLT) {
+ fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
+ }
+ if (fGlobalTrigger== 0x0 && cGLT) {
+ fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
+ }
}
if (TreeD() && fDigits && cD) {
for (int i=0; i<AliMUONConstants::NCh(); i++) {
sprintf(branchname,"%sDigits%d",GetName(),i+1);
- branch = TreeD()->GetBranch(branchname);
- 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);
+ if (fDigits) {
+ branch = TreeD()->GetBranch(branchname);
+ TClonesArray * digits = Digits(i);
+ if (branch) {
+ branch->SetAddress( &digits );
+ }
+ else AliWarning(Form("(%s) Failed for Digits Detection plane %d. Can not find branch in tree.",GetName(),i));
+ }
+ }
+ }
+ if ( TreeD() && fLocalTrigger && cGLT) {
+ sprintf(branchname,"%sLocalTrigger",GetName());
+ branch = TreeD()->GetBranch(branchname);
+ if (branch) branch->SetAddress(&fLocalTrigger);
+ else AliWarning(Form("(%s) Failed for LocalTrigger. Can not find branch in treeD.",GetName()));
+ }
+ if ( TreeD() && fGlobalTrigger && cGLT) {
+ sprintf(branchname,"%sGlobalTrigger",GetName());
+ branch = TreeD()->GetBranch(branchname);
+ if (branch) branch->SetAddress(&fGlobalTrigger);
+ else AliWarning(Form("(%s) Failed for GlobalTrigger. Can not find branch in treeD.",GetName()));
+ }
+
+ //
+ // Branch address for Sdigit tree
+ if ( TreeS() && cS) {
+ if (fSDigits == 0x0) {
+ fSDigits = new TObjArray(AliMUONConstants::NCh());
+ fNSdigits= new Int_t[AliMUONConstants::NCh()];
+ for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
+ fSDigits->AddAt(new TClonesArray("AliMUONDigit",10000),i);
+ fNSdigits[i]=0;
+ }
+ }
+ }
+
+ if (TreeS() && fSDigits && cS) {
+ for (int i=0; i<AliMUONConstants::NCh(); i++) {
+ sprintf(branchname,"%sSDigits%d",GetName(),i+1);
+ if (fSDigits) {
+ branch = TreeS()->GetBranch(branchname);
+ TClonesArray * sdigits = SDigits(i);
+ if (branch) branch->SetAddress( &sdigits );
+ else AliWarning(Form("(%s) Failed for SDigits Detection plane %d. Can not find branch in tree.",GetName(),i));
+ }
}
}
fNrawclusters[i]=0;
}
}
- if (fLocalTrigger == 0x0 && cGLT) {
+ if (fLocalTrigger == 0x0 && cTC) {
fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
}
- if (fGlobalTrigger== 0x0 && cGLT) {
+ if (fGlobalTrigger== 0x0 && cTC) {
fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
}
sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
if (fRawClusters) {
branch = TreeR()->GetBranch(branchname);
- if (branch) branch->SetAddress(&((*fRawClusters)[i]));
- else Warning("SetTreeAddress","(%s) Failed for RawClusters Detection plane %d. Can not find branch in tree.",GetName(),i);
+ if (branch) branch->SetAddress( &((*fRawClusters)[i]) );
+ else AliWarning(Form("(%s) Failed for RawClusters Detection plane %d. Can not find branch in tree.",GetName(),i));
}
}
}
- if ( TreeR() && fLocalTrigger && cGLT) {
+ if ( TreeR() && fLocalTrigger && cTC) {
sprintf(branchname,"%sLocalTrigger",GetName());
branch = TreeR()->GetBranch(branchname);
if (branch) branch->SetAddress(&fLocalTrigger);
- else Warning("SetTreeAddress","(%s) Failed for LocalTrigger. Can not find branch in tree.",GetName());
+ else AliWarning(Form("(%s) Failed for LocalTrigger. Can not find branch in treeR.",GetName()));
}
- if ( TreeR() && fGlobalTrigger && cGLT) {
+ if ( TreeR() && fGlobalTrigger && cTC) {
sprintf(branchname,"%sGlobalTrigger",GetName());
branch = TreeR()->GetBranch(branchname);
if (branch) branch->SetAddress(&fGlobalTrigger);
- else Warning("SetTreeAddress","(%s) Failed for LocalTrigger. Can not find branch in tree.",GetName());
+ else AliWarning(Form("(%s) Failed for GlobalTrigger. Can not find branch in treeR.",GetName()));
}
+ if ( TreeT() ) {
+ if (fRecTracks == 0x0 && cRT) {
+ fRecTracks = new TClonesArray("AliMUONTrack",100);
+ }
+
+ }
if ( TreeT() && fRecTracks && cRT ) {
sprintf(branchname,"%sTrack",GetName());
branch = TreeT()->GetBranch(branchname);
if (branch) branch->SetAddress(&fRecTracks);
- else Warning("SetTreeAddress","(%s) Failed for Tracks. Can not find branch in tree.",GetName());
+ else AliWarning(Form("(%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 AliWarning(Form("(%s) Failed for Trigger Tracks. Can not find branch in tree.",GetName()));
+ }
+
+
}
//_____________________________________________________________________________
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff